Template Upload

node_modules/es6-shim/test/promise/all.js

@@ -0,0 +1,203 @@
+/* global it, describe, expect, assert, Promise */
+
+var failIfThrows = function (done) {
+  'use strict';
+
+  return function (e) {
+    done(e || new Error());
+  };
+};
+
+describe('Promise.all', function () {
+  'use strict';
+
+  it('should not be enumerable', function () {
+    expect(Promise).ownPropertyDescriptor('all').to.have.property('enumerable', false);
+  });
+
+  it('fulfills if passed an empty array', function (done) {
+    var iterable = [];
+
+    Promise.all(iterable).then(function (value) {
+      assert(Array.isArray(value));
+      assert.deepEqual(value, []);
+    }).then(done, failIfThrows(done));
+  });
+
+  it('fulfills if passed an empty array-like', function (done) {
+    var f = function () {
+      Promise.all(arguments).then(function (value) {
+        assert(Array.isArray(value));
+        assert.deepEqual(value, []);
+      }).then(done, failIfThrows(done));
+    };
+    f();
+  });
+
+  it('fulfills if passed an array of mixed fulfilled promises and values', function (done) {
+    var iterable = [0, Promise.resolve(1), 2, Promise.resolve(3)];
+
+    Promise.all(iterable).then(function (value) {
+      assert(Array.isArray(value));
+      assert.deepEqual(value, [0, 1, 2, 3]);
+    }).then(done, failIfThrows(done));
+  });
+
+  it('rejects if any passed promise is rejected', function (done) {
+    var foreverPending = new Promise(function () { });
+    var error = new Error('Rejected');
+    var rejected = Promise.reject(error);
+
+    var iterable = [foreverPending, rejected];
+
+    Promise.all(iterable).then(
+      function () {
+        assert(false, 'should never get here');
+      },
+      function (reason) {
+        assert.strictEqual(reason, error);
+      }
+    ).then(done, failIfThrows(done));
+  });
+
+  it('resolves foreign thenables', function (done) {
+    var normal = Promise.resolve(1);
+    var foreign = { then: function (f) { f(2); } };
+
+    var iterable = [normal, foreign];
+
+    Promise.all(iterable).then(function (value) {
+      assert.deepEqual(value, [1, 2]);
+    }).then(done, failIfThrows(done));
+  });
+
+  it('fulfills when passed an sparse array, giving `undefined` for the omitted values', function (done) {
+    /* jshint elision: true */
+    /* jscs:disable disallowSpaceBeforeComma */
+    /* jscs:disable requireSpaceAfterComma */
+    /* eslint-disable no-sparse-arrays */
+    var iterable = [Promise.resolve(0), , , Promise.resolve(1)];
+    /* eslint-enable no-sparse-arrays */
+    /* jscs:enable requireSpaceAfterComma */
+    /* jscs:enable disallowSpaceBeforeComma */
+    /* jshint elision: false */
+
+    Promise.all(iterable).then(function (value) {
+      assert.deepEqual(value, [0, undefined, undefined, 1]);
+    }).then(done, failIfThrows(done));
+  });
+
+  it('does not modify the input array', function (done) {
+    var input = [0, 1];
+    var iterable = input;
+
+    Promise.all(iterable).then(function (value) {
+      assert.notStrictEqual(input, value);
+    }).then(done, failIfThrows(done));
+  });
+
+  it('should reject with a TypeError if given a non-iterable', function (done) {
+    var notIterable = {};
+
+    Promise.all(notIterable).then(
+      function () {
+        assert(false, 'should never get here');
+      },
+      function (reason) {
+        assert(reason instanceof TypeError);
+      }
+    ).then(done, failIfThrows(done));
+  });
+
+  // test cases from
+  // https://github.com/domenic/promises-unwrapping/issues/89#issuecomment-33110203
+  var tamper = function (p) {
+    p.then = function (fulfill, reject) {
+      fulfill('tampered');
+      return Promise.prototype.then.call(this, fulfill, reject);
+    };
+    return p;
+  };
+
+  it('should be robust against tampering (1)', function (done) {
+    var g = [tamper(Promise.resolve(0))];
+    // Prevent countdownHolder.[[Countdown]] from ever reaching zero
+    Promise.all(g).then(
+      function () { done(); },
+      failIfThrows(done)
+    );
+  });
+
+  it('should be robust against tampering (2)', function (done) {
+    // Promise from Promise.all resolved before arguments
+    var fulfillCalled = false;
+
+    var g = [
+      Promise.resolve(0),
+      tamper(Promise.resolve(1)),
+      Promise.resolve(2).then(function () {
+        assert(!fulfillCalled, 'should be resolved before all()');
+      }).then(function () {
+        assert(!fulfillCalled, 'should be resolved before all()');
+      })['catch'](failIfThrows(done))
+    ];
+    Promise.all(g).then(function () {
+      assert(!fulfillCalled, 'should be resolved last');
+      fulfillCalled = true;
+    }).then(done, failIfThrows(done));
+  });
+
+  it('should be robust against tampering (3)', function (done) {
+    var g = [
+      Promise.resolve(0),
+      tamper(Promise.resolve(1)),
+      Promise.reject(2)
+    ];
+    // Promise from Promise.all resolved despite rejected promise in arguments
+    Promise.all(g).then(function () {
+      throw new Error('should not reach here!');
+    }, function (e) {
+      assert.strictEqual(e, 2);
+    }).then(done, failIfThrows(done));
+  });
+
+  it('should be robust against tampering (4)', function (done) {
+    var hijack = true;
+    var actualArguments = [];
+    var P = function (resolver) {
+      var self;
+      if (hijack) {
+        hijack = false;
+        self = new Promise(function (resolve, reject) {
+          return resolver(function (values) {
+            // record arguments & # of times resolve function is called
+            actualArguments.push(values.slice());
+            return resolve(values);
+          }, reject);
+        });
+      } else {
+        self = new Promise(resolver);
+      }
+      Object.setPrototypeOf(self, P.prototype);
+      return self;
+    };
+    if (!Object.setPrototypeOf) { return done(); } // skip test if on IE < 11
+    Object.setPrototypeOf(P, Promise);
+    P.prototype = Object.create(Promise.prototype, {
+      constructor: { value: P }
+    });
+    P.resolve = function (p) { return p; };
+
+    var g = [
+      Promise.resolve(0),
+      tamper(Promise.resolve(1)),
+      Promise.resolve(2)
+    ];
+
+    // Promise.all calls resolver twice
+    P.all(g)['catch'](failIfThrows(done));
+    Promise.resolve().then(function () {
+      assert.deepEqual(actualArguments, [[0, 'tampered', 2]]);
+    }).then(done, failIfThrows(done));
+  });
+});

node_modules/es6-shim/test/promise/evil-promises.js

@@ -0,0 +1,36 @@
+describe('Evil promises should not be able to break invariants', function () {
+  'use strict';
+
+  specify('resolving to a promise that calls onFulfilled twice', function (done) {
+    // note that we have to create a trivial subclass, as otherwise the
+    // Promise.resolve(evilPromise) is just the identity function.
+    // (And in fact, most native Promise implementations use a private
+    // [[PromiseConstructor]] field in `Promise.resolve` which can't be
+    // easily patched in an ES5 engine, so instead of
+    // `Promise.resolve(evilPromise)` we'll use
+    // `new Promise(function(r){r(evilPromise);})` below.)
+    var EvilPromise = function (executor) {
+      var self = new Promise(executor);
+      Object.setPrototypeOf(self, EvilPromise.prototype);
+      return self;
+    };
+    if (!Object.setPrototypeOf) { return done(); } // skip test if on IE < 11
+    Object.setPrototypeOf(EvilPromise, Promise);
+    EvilPromise.prototype = Object.create(Promise.prototype, {
+      constructor: { value: EvilPromise }
+    });
+
+    var evilPromise = EvilPromise.resolve();
+    evilPromise.then = function (f) {
+      f(1);
+      f(2);
+    };
+
+    var calledAlready = false;
+    new Promise(function (r) { r(evilPromise); }).then(function (value) {
+      assert.strictEqual(calledAlready, false);
+      calledAlready = true;
+      assert.strictEqual(value, 1);
+    }).then(done, done);
+  });
+});

node_modules/es6-shim/test/promise/promises-aplus.js

@@ -0,0 +1,23 @@
+// tests from promises-aplus-tests
+
+describe('Promises/A+ Tests', function () {
+  'use strict';
+
+  if (typeof Promise === 'undefined') {
+    return;
+  }
+
+  require('promises-aplus-tests').mocha({
+    // an adapter from es6 spec to Promises/A+
+    deferred: function () {
+      var result = {};
+      result.promise = new Promise(function (resolve, reject) {
+        result.resolve = resolve;
+        result.reject = reject;
+      });
+      return result;
+    },
+    resolved: Promise.resolve.bind(Promise),
+    rejected: Promise.reject.bind(Promise)
+  });
+});

node_modules/es6-shim/test/promise/promises-es6.js

@@ -0,0 +1,22 @@
+// tests from promises-es6-tests
+(function () {
+  'use strict';
+
+  if (typeof Promise === 'undefined') {
+    return;
+  }
+
+  describe('Promises/ES6 Tests', function () {
+
+    // an adapter that sets up global.Promise
+    // since it's already set up, empty functions will suffice
+    var adapter = {
+      defineGlobalPromise: function () {
+      },
+      removeGlobalPromise: function () {
+      }
+    };
+
+    require('promises-es6-tests').mocha(adapter);
+  });
+}());

node_modules/es6-shim/test/promise/race.js

@@ -0,0 +1,88 @@
+var failIfThrows = function (done) {
+  'use strict';
+
+  return function (e) {
+    done(e || new Error());
+  };
+};
+
+var delayPromise = function (value, ms) {
+  'use strict';
+
+  return new Promise(function (resolve) {
+    setTimeout(function () {
+      resolve(value);
+    }, ms);
+  });
+};
+
+describe('Promise.race', function () {
+  'use strict';
+
+  it('should not be enumerable', function () {
+    expect(Promise).ownPropertyDescriptor('race').to.have.property('enumerable', false);
+  });
+
+  it('should fulfill if all promises are settled and the ordinally-first is fulfilled', function (done) {
+    var iterable = [Promise.resolve(1), Promise.reject(2), Promise.resolve(3)];
+
+    Promise.race(iterable).then(function (value) {
+      assert.strictEqual(value, 1);
+    }).then(done, failIfThrows(done));
+  });
+
+  it('should reject if all promises are settled and the ordinally-first is rejected', function (done) {
+    var iterable = [Promise.reject(1), Promise.reject(2), Promise.resolve(3)];
+
+    Promise.race(iterable).then(
+      function () {
+        assert(false, 'should never get here');
+      },
+      function (reason) {
+        assert.strictEqual(reason, 1);
+      }
+    ).then(done, failIfThrows(done));
+  });
+
+  it('should settle in the same way as the first promise to settle', function (done) {
+    // ensure that even if timeouts are delayed an all execute together,
+    // p2 will settle first.
+    var p2 = delayPromise(2, 200);
+    var p1 = delayPromise(1, 1000);
+    var p3 = delayPromise(3, 500);
+    var iterable = [p1, p2, p3];
+
+    Promise.race(iterable).then(function (value) {
+      assert.strictEqual(value, 2);
+    }).then(done, failIfThrows(done));
+  });
+
+  // see https://github.com/domenic/promises-unwrapping/issues/75
+  it('should never settle when given an empty iterable', function (done) {
+    var iterable = [];
+    var settled = false;
+
+    Promise.race(iterable).then(
+      function () { settled = true; },
+      function () { settled = true; }
+    );
+
+    setTimeout(function () {
+      assert.strictEqual(settled, false);
+      done();
+    }, 300);
+  });
+
+  it('should reject with a TypeError if given a non-iterable', function (done) {
+    var notIterable = {};
+
+    Promise.race(notIterable).then(
+      function () {
+        assert(false, 'should never get here');
+      },
+      function (reason) {
+        assert(reason instanceof TypeError);
+      }
+    ).then(done, failIfThrows(done));
+  });
+});

node_modules/es6-shim/test/promise/reject.js

@@ -0,0 +1,34 @@
+var failIfThrows = function (done) {
+  'use strict';
+
+  return function (e) {
+    done(e || new Error());
+  };
+};
+
+describe('Promise.reject', function () {
+  'use strict';
+
+  it('should not be enumerable', function () {
+    expect(Promise).ownPropertyDescriptor('reject').to.have.property('enumerable', false);
+  });
+
+  it('should return a rejected promise', function (done) {
+    var value = {};
+    Promise.reject(value).then(failIfThrows(done), function (result) {
+      expect(result).to.equal(value);
+      done();
+    });
+  });
+
+  it('throws when receiver is a primitive', function () {
+    var promise = Promise.reject();
+    expect(function () { Promise.reject.call(undefined, promise); }).to['throw']();
+    expect(function () { Promise.reject.call(null, promise); }).to['throw']();
+    expect(function () { Promise.reject.call('', promise); }).to['throw']();
+    expect(function () { Promise.reject.call(42, promise); }).to['throw']();
+    expect(function () { Promise.reject.call(false, promise); }).to['throw']();
+    expect(function () { Promise.reject.call(true, promise); }).to['throw']();
+    promise.then(null, function () {}); // silence unhandled rejection errors in Chrome
+  });
+});

node_modules/es6-shim/test/promise/resolve.js

@@ -0,0 +1,33 @@
+var failIfThrows = function (done) {
+  'use strict';
+
+  return function (e) {
+    done(e || new Error());
+  };
+};
+
+describe('Promise.resolve', function () {
+  'use strict';
+
+  it('should not be enumerable', function () {
+    expect(Promise).ownPropertyDescriptor('resolve').to.have.property('enumerable', false);
+  });
+
+  it('should return a resolved promise', function (done) {
+    var value = {};
+    Promise.resolve(value).then(function (result) {
+      expect(result).to.equal(value);
+      done();
+    }, failIfThrows(done));
+  });
+
+  it('throws when receiver is a primitive', function () {
+    var promise = Promise.resolve();
+    expect(function () { Promise.resolve.call(undefined, promise); }).to['throw']();
+    expect(function () { Promise.resolve.call(null, promise); }).to['throw']();
+    expect(function () { Promise.resolve.call('', promise); }).to['throw']();
+    expect(function () { Promise.resolve.call(42, promise); }).to['throw']();
+    expect(function () { Promise.resolve.call(false, promise); }).to['throw']();
+    expect(function () { Promise.resolve.call(true, promise); }).to['throw']();
+  });
+});

node_modules/es6-shim/test/promise/simple.js

@@ -0,0 +1,96 @@
+var failIfThrows = function (done) {
+  'use strict';
+
+  return function (e) {
+    done(e || new Error());
+  };
+};
+
+describe('Promise', function () {
+  'use strict';
+
+  specify('sanity check: a fulfilled promise calls its fulfillment handler', function (done) {
+    Promise.resolve(5).then(function (value) {
+      assert.strictEqual(value, 5);
+    }).then(done, failIfThrows(done));
+  });
+
+  specify('directly resolving the promise with itself', function (done) {
+    var resolvePromise;
+    var promise = new Promise(function (resolve) { resolvePromise = resolve; });
+
+    resolvePromise(promise);
+
+    promise.then(
+      function () {
+        assert(false, 'Should not be fulfilled');
+      },
+      function (err) {
+        assert(err instanceof TypeError);
+      }
+    ).then(done, failIfThrows(done));
+  });
+
+  specify('Stealing a resolver and using it to trigger possible reentrancy bug (#83)', function () {
+    var stolenResolver;
+    var StealingPromiseConstructor = function StealingPromiseConstructor(resolver) {
+      stolenResolver = resolver;
+      resolver(function () { }, function () { });
+    };
+
+    var iterable = {};
+    var atAtIterator = '@@iterator'; // on firefox, at least.
+    iterable[atAtIterator] = function () {
+      stolenResolver(null, null);
+      throw new Error(0);
+    };
+
+    assert.doesNotThrow(function () {
+      Promise.all.call(StealingPromiseConstructor, iterable);
+    });
+  });
+
+  specify('resolve with a thenable calls it once', function () {
+    var resolve;
+    var p = new Promise(function (r) { resolve = r; });
+    var count = 0;
+    resolve({
+      then: function () {
+        count += 1;
+        throw new RangeError('reject the promise');
+      }
+    });
+    var a = p.then(function () {})['catch'](function (err) {
+      assert.equal(count, 1);
+      assert.ok(err instanceof RangeError);
+    });
+    var b = p.then(function () {})['catch'](function (err) {
+      assert.equal(count, 1);
+      assert.ok(err instanceof RangeError);
+    });
+    return Promise.all([a, b]);
+  });
+
+  specify('resolve with a thenable that throws on .then, rejects the promise synchronously', function () {
+    var resolve;
+    var p = new Promise(function (r) { resolve = r; });
+    var count = 0;
+    var thenable = Object.defineProperty({}, 'then', {
+      get: function () {
+        count += 1;
+        throw new RangeError('no then for you');
+      }
+    });
+    resolve(thenable);
+    assert.equal(count, 1);
+    var a = p.then(function () {})['catch'](function (err) {
+      assert.equal(count, 1);
+      assert.ok(err instanceof RangeError);
+    });
+    var b = p.then(function () {})['catch'](function (err) {
+      assert.equal(count, 1);
+      assert.ok(err instanceof RangeError);
+    });
+    return Promise.all([a, b]);
+  });
+});

node_modules/es6-shim/test/promise/subclass.js

@@ -0,0 +1,47 @@
+/* global it, describe, assert, Promise */
+
+describe('Support user subclassing of Promise', function () {
+  'use strict';
+
+  it('should work if you do it right', function (done) {
+    // This is the "correct" es6-compatible way.
+    // (Thanks, @domenic and @zloirock!)
+    var MyPromise = function (executor) {
+      var self = new Promise(executor);
+      Object.setPrototypeOf(self, MyPromise.prototype);
+      self.mine = 'yeah';
+      return self;
+    };
+    if (!Object.setPrototypeOf) { return done(); } // skip test if on IE < 11
+    Object.setPrototypeOf(MyPromise, Promise);
+    MyPromise.prototype = Object.create(Promise.prototype, {
+      constructor: { value: MyPromise }
+    });
+
+    // let's try it!
+    var p1 = MyPromise.resolve(5);
+    assert.strictEqual(p1.mine, 'yeah');
+    p1 = p1.then(function (x) {
+      assert.strictEqual(x, 5);
+    });
+    assert.strictEqual(p1.mine, 'yeah');
+
+    var p2 = new MyPromise(function (r) { r(6); });
+    assert.strictEqual(p2.mine, 'yeah');
+    p2 = p2.then(function (x) {
+      assert.strictEqual(x, 6);
+    });
+    assert.strictEqual(p2.mine, 'yeah');
+
+    var p3 = MyPromise.all([p1, p2]);
+    assert.strictEqual(p3.mine, 'yeah');
+    p3.then(function () { done(); }, done);
+  });
+
+  it("should throw if you don't inherit at all", function () {
+    var MyPromise = function () {};
+    assert['throws'](function () {
+      Promise.all.call(MyPromise, []);
+    }, TypeError);
+  });
+});