Support misbehaving promises in Promise.all

Author: Forbes Lindesay

src/core.js

@@ -64,6 +64,7 @@ function Promise(fn) {
   if (fn === noop) return;
   doResolve(fn, this);
 }
+Promise._noop = noop;
 
 Promise.prototype.then = function(onFulfilled, onRejected) {
   if (this.constructor !== Promise) {

src/es6-extensions.js

@@ -9,29 +9,19 @@ module.exports = Promise;
 
 /* Static Functions */
 
-function ValuePromise(value) {
-  this.then = function (onFulfilled) {
-    if (typeof onFulfilled !== 'function') return this;
-    return new Promise(function (resolve, reject) {
-      asap(function () {
-        try {
-          resolve(onFulfilled(value));
-        } catch (ex) {
-          reject(ex);
-        }
-      });
-    });
-  };
+var TRUE = valuePromise(true);
+var FALSE = valuePromise(false);
+var NULL = valuePromise(null);
+var UNDEFINED = valuePromise(undefined);
+var ZERO = valuePromise(0);
+var EMPTYSTRING = valuePromise('');
+
+function valuePromise(value) {
+  var p = new Promise(Promise._noop);
+  p._state = 1;
+  p._value = value;
+  return p;
 }
-ValuePromise.prototype = Promise.prototype;
-
-var TRUE = new ValuePromise(true);
-var FALSE = new ValuePromise(false);
-var NULL = new ValuePromise(null);
-var UNDEFINED = new ValuePromise(undefined);
-var ZERO = new ValuePromise(0);
-var EMPTYSTRING = new ValuePromise('');
-
 Promise.resolve = function (value) {
   if (value instanceof Promise) return value;
 
@@ -54,8 +44,7 @@ Promise.resolve = function (value) {
       });
     }
   }
-
-  return new ValuePromise(value);
+  return valuePromise(value);
 };
 
 Promise.all = function (arr) {
@@ -66,12 +55,25 @@ Promise.all = function (arr) {
     var remaining = args.length;
     function res(i, val) {
       if (val && (typeof val === 'object' || typeof val === 'function')) {
-        var then = val.then;
-        if (typeof then === 'function') {
-          then.call(val, function (val) {
+        if (val instanceof Promise && val.then === Promise.prototype.then) {
+          while (val._state === 3) {
+            val = val._value;
+          }
+          if (val._state === 1) return res(i, val._value);
+          if (val._state === 2) reject(val._value);
+          val.then(function (val) {
             res(i, val);
           }, reject);
           return;
+        } else {
+          var then = val.then;
+          if (typeof then === 'function') {
+            var p = new Promise(then.bind(val));
+            p.then(function (val) {
+              res(i, val);
+            }, reject);
+            return;
+          }
         }
       }
       args[i] = val;

test/extensions-tests.js

@@ -158,15 +158,19 @@ describe('extensions', function () {
       })
       describe('of promises', function () {
         it('returns a promise for an array containing the fulfilled values', function (done) {
-          var res = Promise.all([A, B, C])
+          var d = {}
+          var resolveD
+          var res = Promise.all([A, B, C, new Promise(function (resolve) { resolveD = resolve })])
           assert(res instanceof Promise)
           res.then(function (res) {
             assert(Array.isArray(res))
             assert(res[0] === a)
             assert(res[1] === b)
             assert(res[2] === c)
+            assert(res[3] === d)
           })
           .nodeify(done)
+          resolveD(d)
         })
       })
       describe('of mixed values', function () {
@@ -195,6 +199,38 @@ describe('extensions', function () {
           .nodeify(done)
         })
       })
+      describe('containing at least one eventually rejected promise', function () {
+        it('rejects the resulting promise', function (done) {
+          var rejectB
+          var rejected = new Promise(function (resolve, reject) { rejectB = reject })
+          var res = Promise.all([A, rejected, C])
+          assert(res instanceof Promise)
+          res.then(function (res) {
+            throw new Error('Should be rejected')
+          },
+          function (err) {
+            assert(err === rejection)
+          })
+          .nodeify(done)
+          rejectB(rejection)
+        })
+      })
+      describe('with a promise that resolves twice', function () {
+        it('still waits for all the other promises', function (done) {
+          var fakePromise = {then: function (onFulfilled) { onFulfilled(1); onFulfilled(2) }}
+          var eventuallyRejected = {then: function (_, onRejected) { this.onRejected = onRejected }}
+          var res = Promise.all([fakePromise, eventuallyRejected])
+          assert(res instanceof Promise)
+          res.then(function (res) {
+            throw new Error('Should be rejected')
+          },
+          function (err) {
+            assert(err === rejection)
+          })
+          .nodeify(done)
+          eventuallyRejected.onRejected(rejection);
+        })
+      })
     })
   })