src/third_party/trace-viewer/third_party/tvcm/third_party/Promises/polyfill/tests/Promise-tests.js

   1 // Copyright (C) 2013:
   2 //    Alex Russell (slightlyoff@chromium.org)
   3 // Use of this source code is governed by
   4 //    http://www.apache.org/licenses/LICENSE-2.0
   5
   6 (function() {
   7 "use strict";
   8
   9 var t = doh;
  10
  11 //
  12 // Trivial utilities.
  13 //
  14 var log = console.log.bind(console);
  15
  16 var rejected = Promise.reject;
  17 var asyncRejected = function(reason) {
  18   return new Promise(function(r) {
  19     setTimeout(r.reject.bind(r, reason), 0);
  20   });
  21 };
  22
  23 var fulfilled = Promise.fulfill;
  24 var asyncAccepted = function(value) {
  25   return new Promise(function(r) {
  26     setTimeout(r.fulfill.bind(r, value), 0);
  27   });
  28 };
  29
  30 var resolved = Promise.resolve;
  31 var asyncResolved = function(value) {
  32   return new Promise(function(r) {
  33     setTimeout(r.resolve.bind(r, value), 0);
  34   });
  35 };
  36
  37 var pending = function() {
  38   var resolver;
  39   var future = new Promise(function(r) { resolver = r; });
  40   return {
  41     future: future,
  42     fulfill: resolver.fulfill,
  43     reject: resolver.reject,
  44     resolve: resolver.resolve,
  45   };
  46 };
  47
  48 var dummy = { dummy: "dummy" };
  49 var sentinel = { sentinel: "sentinel" };
  50 var fulfilledSentinel = fulfilled(sentinel);
  51 var rejectedSentinel = rejected(sentinel);
  52
  53 var async = function(desc, test) {
  54   return {
  55     name: desc,
  56     runTest: function() {
  57       var d = new doh.Deferred();
  58       test(d, d.callback.bind(d), d.errback.bind(d));
  59       return d;
  60     }
  61   };
  62 };
  63
  64 t.add("Promise", [
  65   function prototypeMethods() {
  66     t.is(typeof Promise.prototype.then, "function");
  67     t.is(Promise.prototype.then.length, 2);
  68     t.is(typeof Promise.prototype.catch, "function");
  69     t.is(Promise.prototype.catch.length, 1);
  70
  71     var c = 0;
  72     for(var x in Promise.prototype) { c++; }
  73     t.is(c, 2);
  74   },
  75
  76   function no_arg_ctor() {
  77     var future = new Promise();
  78     t.is("pending", future._state);
  79   },
  80
  81   function base_state() {
  82     var resolver;
  83     t.is(undefined, resolver);
  84     var future = new Promise(function(r) { resolver = r; });
  85     t.t(future instanceof Promise);
  86     t.is(undefined, future._value);
  87     t.is(undefined, future._error);
  88     t.is("pending", future._state);
  89     t.is("object", typeof resolver);
  90     t.is(false, resolver._isResolved);
  91   },
  92
  93   async("Is delivery delayed?", function(d) {
  94     var resolver;
  95     var resolved = false;
  96     var future = new Promise(function(r) { resolver = r; });
  97     future.then(function(value) {
  98       resolved = true;
  99       t.is(true, value);
 100       d.callback(value);
 101     });
 102
 103     t.is(future._state, "pending");
 104     t.is(false, resolved);
 105     // t.is(false, resolver._isResolved);
 106     resolver.resolve(true);
 107     // FIXME: what should future._value be here?
 108
 109     t.is("pending", future._state);
 110     t.is(true, resolver._isResolved);
 111   }),
 112
 113   function then_does_not_return_self() {
 114     var f = new Promise();
 115     t.t(f.then() !== f);
 116   },
 117
 118   function catch_does_not_return_self() {
 119     var f = new Promise();
 120     t.t(f.catch() !== f);
 121   },
 122
 123   async("Values forward correctly", function(d) {
 124     var eb = d.errback.bind(d);
 125     var f = fulfilled(dummy);
 126     f.then()
 127      .then(null, eb)
 128      .then(function(e) {
 129         t.is(dummy, e);
 130         d.callback();
 131      }, eb);
 132   }),
 133
 134   async("Errors forward correctly", function(d) {
 135     var f = rejected("meh");
 136     f.then(log)
 137      .then(log, function(e) {
 138         t.is("meh", e);
 139         d.callback();
 140      });
 141   }),
 142 ]);
 143
 144 doh.add("Resolver", [
 145
 146   function invariants() {
 147     new Promise(function(r) {
 148       t.is(r._isResolved, false)
 149       var isResolvedPD = Object.getOwnPropertyDescriptor(r, "_isResolved");
 150       t.is("function", typeof isResolvedPD.get);
 151       t.is("undefined", typeof isResolvedPD.set);
 152       t.t(isResolvedPD.enumerable);
 153       t.f(isResolvedPD.configurable);
 154
 155       t.is("function", typeof r.fulfill);
 156       t.is("function", typeof r.reject);
 157       t.is("function", typeof r.resolve);
 158       t.is("function", typeof r.cancel);
 159       t.is("function", typeof r.timeout);
 160     });
 161   },
 162
 163   async("cancel", function(d) {
 164     var resolver;
 165     var future = new Promise(function(r) {
 166       try {
 167         resolver = r;
 168         t.f(r._isResolved);
 169         r.cancel();
 170         t.t(resolver._isResolved);
 171       } catch(e) {
 172         d.errback(e);
 173       }
 174     });
 175     t.is("pending", future._state);
 176     future.then(
 177       d.errback.bind(d),
 178       function(e) {
 179         t.is("object", typeof e);
 180         t.t(e instanceof Error);
 181         // FIXME: e doesn't seem to have a .name property!!!
 182         t.is("Error: Cancel", e.toString());
 183         d.callback();
 184       }
 185     );
 186     t.t(resolver._isResolved);
 187     t.is("pending", future._state);
 188   }),
 189
 190   async("timeout", function(d) {
 191     var resolver;
 192     var future = new Promise(function(r) {
 193       try {
 194         resolver = r;
 195         t.f(r._isResolved);
 196         r.timeout();
 197         t.t(resolver._isResolved);
 198       } catch(e) {
 199         d.errback(e);
 200       }
 201     });
 202     t.is("pending", future._state);
 203     future.then(
 204       d.errback.bind(d),
 205       function(e) {
 206         t.is("object", typeof e);
 207         t.t(e instanceof Error);
 208         t.is("Error: Timeout", e.toString());
 209         d.callback();
 210       }
 211     );
 212     t.t(resolver._isResolved);
 213     t.is("pending", future._state);
 214   }),
 215
 216   async("resolve forwards errors", function(d) {
 217     var e = new Error("synthetic");
 218     var resolver;
 219     var f1 = new Promise(function(r) {
 220       r.reject(e);
 221     });
 222     var f2 = new Promise(function(r) {
 223       r.resolve(f1);
 224     });
 225     f2.then(
 226       d.errback.bind(d),
 227       function(err) {
 228         t.is("object", typeof err);
 229         t.t(err instanceof Error);
 230         t.is("Error: synthetic", err.toString());
 231         t.is(e.toString(), err.toString());
 232         t.is(e, err);
 233         d.callback();
 234       }
 235     );
 236   }),
 237
 238   async("resolve forwards values", function(d) {
 239     var v = new Error("synthetic");
 240     var resolver;
 241     var f1 = new Promise(function(r) {
 242       r.fulfill(v);
 243     });
 244     var f2 = new Promise(function(r) {
 245       r.resolve(f1);
 246     });
 247     f2.then(
 248       function(value) {
 249         t.is("object", typeof value);
 250         t.t(value instanceof Error);
 251         t.is("Error: synthetic", value.toString());
 252         t.is(v, value);
 253         d.callback();
 254       },
 255       d.errback.bind(d)
 256     );
 257   }),
 258
 259   async("resolve does not forward non futures", function(d) {
 260     var v = new Error("synthetic");
 261     var resolver;
 262     var f1 = new Promise(function(r) {
 263       r.resolve(v);
 264     });
 265     var f2 = new Promise(function(r) {
 266       r.resolve(f1);
 267     });
 268     f2.then(
 269       function(value) {
 270         t.is("object", typeof value);
 271         t.t(value instanceof Error);
 272         t.is("Error: synthetic", value.toString());
 273         t.is(v, value);
 274         d.callback();
 275       },
 276       d.errback.bind(d)
 277     );
 278   }),
 279
 280   async("resolve forwards values through then", function(d) {
 281     var v = new Error("synthetic");
 282     var resolver;
 283     var f1 = new Promise(function(r) {
 284       r.resolve(v);
 285     });
 286     var f2 = new Promise(function(r) {
 287       r.resolve(f1);
 288     });
 289     var f3 = f2.then(
 290       function(value) {
 291         t.is("object", typeof value);
 292         t.t(value instanceof Error);
 293         t.is("Error: synthetic", value.toString());
 294         t.is(v, value);
 295         return new Promise(function(r) {
 296           r.resolve("some other value");
 297         });
 298       },
 299       function(e) { return e; }
 300     );
 301     f3.then(
 302       function(value) {
 303         t.is("some other value", value);
 304         d.callback();
 305       },
 306       d.errback.bind(d)
 307     );
 308   }),
 309
 310   async("Promises forward through then", function(d, then, error) {
 311     // FIXME(slightlyoff)
 312     then();
 313   }),
 314
 315
 316   async("isResolved is true while forwarding", function(d) {
 317     var f1 = pending();
 318     var r1;
 319     var f2 = new Promise(function(r) {
 320       r1 = r;
 321       r.resolve(f1);
 322     });
 323     t.t(r1._isResolved);
 324     d.callback();
 325   }),
 326
 327   async("Throwing in a then callback rejects next.", function(d, then, e) {
 328     fulfilled(5).then(function(v) {
 329       throw new Error("Blarg!");
 330     }).then(e, function(e){then();});
 331   }),
 332
 333   //
 334   // Inspired by the promises-tests repo.
 335   //
 336   async("non function rejected callbacks are ignored",
 337     function(d, then, error) {
 338       var nonFunction = 10;
 339       rejected(dummy).then(10, then);
 340     }
 341   ),
 342
 343   async("non function fulfilled callbacks are ignored",
 344     function(d, then, error) {
 345       var nonFunction = 10;
 346       fulfilled(dummy).then(then, 10);
 347     }
 348   ),
 349
 350   // Promise.any
 351
 352   async("Promise.any fails on no values", function(d, then, error) {
 353     Promise.any().then(error, then);
 354   }),
 355
 356   async("Promise.any succeeds on undefined", function(d, then, error) {
 357     Promise.any(undefined).then(then, error);
 358   }),
 359
 360   async("Promise.any succeeds on raw values", function(d, then, error) {
 361     Promise.any("thinger", undefined, [], new String("blarg")).then(then, error);
 362   }),
 363
 364   async("Promise.any fails on rejected", function(d, then, error) {
 365     Promise.any(rejected()).then(error, then);
 366   }),
 367
 368   async("Promise.any succeeds on fulfilled", function(d, then, error) {
 369     Promise.any(fulfilled()).then(then, error);
 370   }),
 371
 372   async("Promise.any succeeds on fulfilled sentinel", function(d, then, error) {
 373     Promise.any(fulfilledSentinel).then(then, error);
 374   }),
 375
 376   async("Promise.any succeeds on asyncAccepted", function(d, then, error) {
 377     Promise.any(asyncAccepted()).then(then, error);
 378   }),
 379
 380   async("Promise.any succeeds on value + fulfilled", function(d, then, error) {
 381     Promise.any("thinger", fulfilled(dummy)).then(then, error);
 382   }),
 383
 384   async("Promise.any succeeds on fulfilled + rejected", function(d, then, error) {
 385     Promise.any(fulfilledSentinel, rejectedSentinel).then(then, error);
 386   }),
 387
 388   async("Promise.any fails on rejected + fulfilled", function(d, then, error) {
 389     Promise.any(rejected(dummy), fulfilled("thinger")).then(error, then);
 390   }),
 391
 392   async("Promise.any succeeds on pre-fulfilled + pre-rejected",
 393     function(d, then, error) {
 394       Promise.any(fulfilledSentinel, rejectedSentinel).then(then, error);
 395     }
 396   ),
 397
 398   async("Promise.any succeeds on value + rejected", function(d, then, error) {
 399     Promise.any("value", rejected("error")).then(then, error);
 400   }),
 401
 402   async("Promise.any succeeds on rejected + value", function(d, then, error) {
 403     Promise.any(rejectedSentinel, "thinger").then(then, error);
 404   }),
 405
 406   // Promise.every
 407
 408   async("Promise.every fails on no values", function(d, then, error) {
 409     Promise.every().then(error, then);
 410   }),
 411
 412   async("Promise.every succeeds on undefined", function(d, then, error) {
 413     Promise.every(undefined).then(then, error);
 414   }),
 415
 416   async("Promise.every succeeds on raw values", function(d, then, error) {
 417     Promise.every("thinger", undefined, [], new String("blarg")).then(then, error);
 418   }),
 419
 420   async("Promise.every fails on rejected", function(d, then, error) {
 421     Promise.any(rejected()).then(error, then);
 422   }),
 423
 424   async("Promise.every succeeds on fulfilled", function(d, then, error) {
 425     Promise.every(fulfilled()).then(then, error);
 426   }),
 427
 428   async("Promise.every succeeds on asyncAccepted", function(d, then, error) {
 429     Promise.every(asyncAccepted()).then(then, error);
 430   }),
 431
 432   async("Promise.every fails on rejected + value", function(d, then, error) {
 433     Promise.every(rejected(), "thinger").then(error, then);
 434   }),
 435
 436   async("Promise.every fails on asyncRejected + value", function(d, then, error) {
 437     Promise.every(asyncRejected(), "thinger").then(error, then);
 438   }),
 439
 440   async("Promise.every forwards values", function(d, then, error) {
 441     Promise.every(
 442       Promise.every(asyncAccepted(5), "thinger").then(function(values) {
 443         t.is([5, "thinger"], values);
 444       }),
 445       Promise.every(asyncAccepted(5), "thinger").then(function(values) {
 446         t.is([5, "thinger"], values);
 447       })
 448     ).then(then, error);
 449   }),
 450
 451   async("Promise.every forwards values multiple levels",
 452     function(d, then, error) {
 453       Promise.every(asyncResolved(asyncResolved(5)), "thinger")
 454         .then(function(values) {
 455           t.is([5, "thinger"], values);
 456           then();
 457         }, error);
 458     }
 459   ),
 460
 461   // Promise.some
 462
 463   async("Promise.some fails on no values", function(d, then, error) {
 464     Promise.some().then(error, then);
 465   }),
 466
 467   async("Promise.some succeeds on undefined", function(d, then, error) {
 468     Promise.some(undefined).then(then, error);
 469   }),
 470
 471   async("Promise.some succeeds on raw values", function(d, then, error) {
 472     Promise.some("thinger", undefined, [], new String("blarg")).then(then, error);
 473   }),
 474
 475   async("Promise.some fails on rejected", function(d, then, error) {
 476     Promise.some(rejected()).then(error, then);
 477   }),
 478
 479   async("Promise.some succeeds on fulfilled", function(d, then, error) {
 480     Promise.some(fulfilled()).then(then, error);
 481   }),
 482
 483   async("Promise.some succeeds on asyncAccepted", function(d, then, error) {
 484     Promise.some(asyncAccepted()).then(then, error);
 485   }),
 486
 487   async("Promise.some succeeds on rejected + fulfilled", function(d, then, error) {
 488     Promise.some(rejectedSentinel, fulfilledSentinel).then(then, error);
 489   }),
 490
 491   async("Promise.some succeeds on value + rejected", function(d, then, error) {
 492     Promise.some("thinger", rejectedSentinel).then(then, error);
 493   }),
 494
 495   // Promise.fulfill
 496
 497   async("Promise.fulfill is sane", function(d, then, error) {
 498     Promise.fulfill(sentinel).then(function(v) {
 499       t.is(sentinel, v);
 500       then();
 501     }, error);
 502   }),
 503
 504   // FIXME(slightlyoff): MOAR TESTS
 505
 506
 507   // Promise.resolve
 508
 509   async("Promise.resolve is sane", function(d, then, error) {
 510     Promise.resolve(sentinel).then(function(v) {
 511       t.is(sentinel, v);
 512       then();
 513     }, error);
 514   }),
 515
 516   // FIXME(slightlyoff): MOAR TESTS
 517
 518
 519   // Promise.reject
 520
 521   async("Promise.reject is sane", function(d, then, error) {
 522     Promise.reject(sentinel).then(error, function(reason) {
 523       t.is(sentinel, reason);
 524       then();
 525     });
 526   }),
 527
 528   // FIXME(slightlyoff): MOAR TESTS
 529 ]);
 530
 531 })();