Merge pull request #428 from unexpectedjs/fix/errorOnPromiseAnd

Fix error on promise .and()
unexpectedjs · Nov 20, 2017 · af56da0 · af56da0
2 parents bf22cde + 959e32e
commit af56da0
Show file tree

Hide file tree

Showing 6 changed files with 73 additions and 27 deletions.
diff --git a/lib/Unexpected.js b/lib/Unexpected.js
@@ -5,7 +5,7 @@ var extend = utils.extend;
 var leven = require('leven');
 var makePromise = require('./makePromise');
 var addAdditionalPromiseMethods = require('./addAdditionalPromiseMethods');
-var isPendingPromise = require('./isPendingPromise');
+var wrapPromiseIfNecessary = require('./wrapPromiseIfNecessary');
 var oathbreaker = require('./oathbreaker');
 var UnexpectedError = require('./UnexpectedError');
 var notifyPendingPromise = require('./notifyPendingPromise');
@@ -1207,18 +1207,19 @@ Unexpected.prototype._expect = function expect(context, args) {
 
     try {
         var result = executeExpect(context, subject, testDescriptionString, Array.prototype.slice.call(args, 2));
-        if (isPendingPromise(result)) {
-            that.expect.notifyPendingPromise(result);
-            result = result.then(undefined, function (e) {
-                if (e && e._isUnexpected && context.level === 0) {
-                    that.setErrorMessage(e);
-                }
-                throw e;
-            });
-        } else {
-            if (!result || typeof result.then !== 'function') {
-                result = makePromise.resolve(result);
+        if (utils.isPromise(result)) {
+            result = wrapPromiseIfNecessary(result);
+            if (result.isPending()) {
+                that.expect.notifyPendingPromise(result);
+                result = result.then(undefined, function (e) {
+                    if (e && e._isUnexpected && context.level === 0) {
+                        that.setErrorMessage(e);
+                    }
+                    throw e;
+                });
             }
+        } else {
+            result = makePromise.resolve(result);
         }
         return addAdditionalPromiseMethods(result, that.expect, subject);
     } catch (e) {

diff --git a/lib/createWrappedExpectProto.js b/lib/createWrappedExpectProto.js
@@ -1,9 +1,9 @@
 var createStandardErrorMessage = require('./createStandardErrorMessage');
 var makePromise = require('./makePromise');
-var isPendingPromise = require('./isPendingPromise');
+var addAdditionalPromiseMethods = require('./addAdditionalPromiseMethods');
+var wrapPromiseIfNecessary = require('./wrapPromiseIfNecessary');
 var oathbreaker = require('./oathbreaker');
 var UnexpectedError = require('./UnexpectedError');
-var addAdditionalPromiseMethods = require('./addAdditionalPromiseMethods');
 var utils = require('./utils');
 
 function isAssertionArg(arg) {
@@ -89,16 +89,19 @@ module.exports = function createWrappedExpectProto(unexpected) {
 
             try {
                 var result = oathbreaker(callback());
-                if (isPendingPromise(result)) {
-                    result = result.then(undefined, function (e) {
-                        if (e && e._isUnexpected) {
-                            var wrappedError = new UnexpectedError(that, e);
-                            wrappedError.originalError = e.originalError;
-                            throw wrappedError;
-                        }
-                        throw e;
-                    });
-                } else if (!result || typeof result.then !== 'function') {
+                if (utils.isPromise(result)) {
+                    result = wrapPromiseIfNecessary(result);
+                    if (result.isPending()) {
+                        result = result.then(undefined, function (e) {
+                            if (e && e._isUnexpected) {
+                                var wrappedError = new UnexpectedError(that, e);
+                                wrappedError.originalError = e.originalError;
+                                throw wrappedError;
+                            }
+                            throw e;
+                        });
+                    }
+                } else {
                     result = makePromise.resolve(result);
                 }
                 return addAdditionalPromiseMethods(result, that.execute, that.subject);

diff --git a/lib/isPendingPromise.js b/lib/isPendingPromise.js
diff --git a/lib/utils.js b/lib/utils.js
@@ -24,6 +24,10 @@ var utils = module.exports = {
         return Object.prototype.toString.call(ar) === '[object Array]';
     },
 
+    isPromise: function (obj) {
+        return obj && typeof obj.then === 'function';
+    },
+
     isRegExp: function (re) {
         return (Object.prototype.toString.call(re) === '[object RegExp]');
     },

diff --git a/lib/wrapPromiseIfNecessary.js b/lib/wrapPromiseIfNecessary.js
@@ -0,0 +1,12 @@
+var makePromise = require('./makePromise');
+
+module.exports = function (promise) {
+    if (typeof promise.isPending !== 'function') {
+        // wrap any non-Unexpected promise
+        return makePromise(function () {
+            return promise;
+        });
+    } else {
+        return promise;
+    }
+};
diff --git a/test/api/shift.spec.js b/test/api/shift.spec.js
@@ -202,4 +202,33 @@ describe('expect.shift', function () {
             );
         });
     });
+
+    describe('when a non-Unexpected promise is passed to shift', function () {
+        it('should allow a subsequent .and()', function () {
+            var clonedExpect = expect.clone().addAssertion('promisified', function (expect, subject) {
+                return expect.shift(new Promise(subject));
+            });
+            return clonedExpect(resolve => {
+                setTimeout(function () {
+                    resolve('usefully');
+                }, 100);
+            }, 'promisified').and('to be truthy');
+        });
+
+        it('should allow a subsequent .and() within a nested context', function () {
+            var clonedExpect = expect.clone().addAssertion('promisified', function (expect, subject) {
+                return expect.shift(new Promise(subject));
+            }).addAssertion('<function> executed inside an assertion', function (expect, subject) {
+                return subject(expect);
+            });
+
+            return clonedExpect(expect => {
+                expect(resolve => {
+                    setTimeout(function () {
+                        resolve('usefully');
+                    }, 100);
+                }, 'promisified').and('to be truthy');
+            }, 'executed inside an assertion');
+        });
+    });
 });