chai-as-promised 5.3.0 → 6.0.0

package/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright © 2012–2015 Domenic Denicola <d@domenic.me>
+Copyright © 2012–2016 Domenic Denicola <d@domenic.me>
 
 This work is free. You can redistribute it and/or modify it under the
 terms of the Do What The Fuck You Want To Public License, Version 2,

package/README.md

@@ -124,7 +124,7 @@ chaiAsPromised.transformAsserterArgs = function (args) {
 }
 
 Promise.resolve(2).should.eventually.equal(2); // will now fail!
-Promise.resolve(2).should.eventually.equal(3); // will now pass!
+Promise.resolve(3).should.eventually.equal(2); // will now pass!
 ```
 
 The transform can even be asynchronous, returning a promise for an array instead of an array directly. An example of that might be using `Promise.all` so that an array of promises becomes a promise for an array. If you do that, then you can compare promises against other promises using the asserters:
@@ -144,7 +144,11 @@ Promise.resolve(2).should.eventually.be.within(Promise.resolve(1), Promise.resol
 
 ### Compatibility
 
-Chai as Promised is compatible with all promises following the [Promises/A+ specification][spec]. Notably, jQuery's promises were not up to spec before jQuery 3.0, and Chai as Promised will not work with them. In particular, Chai as Promised makes extensive use of the standard [transformation behavior][] of `then`, which jQuery<3.0 does not support.
+Chai as Promised is compatible with all promises following the [Promises/A+ specification][spec].
+
+Notably, jQuery's promises were not up to spec before jQuery 3.0, and Chai as Promised will not work with them. In particular, Chai as Promised makes extensive use of the standard [transformation behavior][] of `then`, which jQuery<3.0 does not support.
+
+Angular promises have a special digest cycle for their processing, and [need extra setup code to work with Chai as Promised](http://stackoverflow.com/a/37374041/3191).
 
 ### Working with Non-Promise–Friendly Test Runners
 
@@ -202,31 +206,21 @@ var chai = require("chai");
 var chaiAsPromised = require("chai-as-promised");
 
 chai.use(chaiAsPromised);
-```
-
-You can of course put this code in a common test fixture file; for an example using [Mocha][], see [the Chai as Promised tests themselves][fixturedemo].
-
-### AMD
 
-Chai as Promised supports being used as an [AMD][amd] module, registering itself anonymously (just like Chai). So, assuming you have configured your loader to map the Chai and Chai as Promised files to the respective module IDs `"chai"` and `"chai-as-promised"`, you can use them as follows:
-
-```javascript
-define(function (require, exports, module) {
-    var chai = require("chai");
-    var chaiAsPromised = require("chai-as-promised");
-
-    chai.use(chaiAsPromised);
-});
+// Then either:
+var expect = chai.expect;
+// or:
+var assert = chai.assert;
+// or:
+chai.should();
+// according to your preference of assertion style
 ```
 
-### `<script>` tag
+You can of course put this code in a common test fixture file; for an example using [Mocha][], see [the Chai as Promised tests themselves][fixturedemo].
 
-If you include Chai as Promised directly with a `<script>` tag, after the one for Chai itself, then it will automatically plug in to Chai and be ready for use:
+### In the Browser
 
-```html
-<script src="chai.js"></script>
-<script src="chai-as-promised.js"></script>
-```
+To use Chai as Promised in environments that don't support Node.js-like CommonJS modules, you'll need to use a bundling tool like [browserify][].
 
 ### Karma
 
@@ -250,3 +244,4 @@ Chai as Promised is only compatible with modern browsers (IE ≥9, Safari ≥6,
 [sinon-chai]: https://github.com/domenic/sinon-chai
 [Karma]: https://karma-runner.github.io/
 [karma-chai-as-promised]: https://github.com/vlkosinov/karma-chai-as-promised
+[browserify]: http://browserify.org/

package/lib/chai-as-promised.js

@@ -1,375 +1,374 @@
-(function () {
-    "use strict";
-
-    // Module systems magic dance.
-
-    /* istanbul ignore else */
-    if (typeof require === "function" && typeof exports === "object" && typeof module === "object") {
-        // NodeJS
-        module.exports = chaiAsPromised;
-    } else if (typeof define === "function" && define.amd) {
-        // AMD
-        define(function () {
-            return chaiAsPromised;
-        });
-    } else {
-        /*global self: false */
+"use strict";
+var checkError = require("check-error");
+
+module.exports = function (chai, utils) {
+    var Assertion = chai.Assertion;
+    var assert = chai.assert;
+
+    // If we are using a version of Chai that has checkError on it,
+    // we want to use that version to be consistent. Otherwise, we use
+    // what was passed to the factory.
+    if (utils.checkError) {
+        checkError = utils.checkError;
+    }
 
-        // Other environment (usually <script> tag): plug in to global chai instance directly.
-        chai.use(chaiAsPromised);
+    function isLegacyJQueryPromise(thenable) {
+        // jQuery promises are Promises/A+-compatible since 3.0.0. jQuery 3.0.0 is also the first version
+        // to define the catch method.
+        return typeof thenable.catch !== "function" &&
+               typeof thenable.always === "function" &&
+               typeof thenable.done === "function" &&
+               typeof thenable.fail === "function" &&
+               typeof thenable.pipe === "function" &&
+               typeof thenable.progress === "function" &&
+               typeof thenable.state === "function";
+    }
 
-        // Expose as a property of the global object so that consumers can configure the `transferPromiseness` property.
-        self.chaiAsPromised = chaiAsPromised;
+    function assertIsAboutPromise(assertion) {
+        if (typeof assertion._obj.then !== "function") {
+            throw new TypeError(utils.inspect(assertion._obj) + " is not a thenable.");
+        }
+        if (isLegacyJQueryPromise(assertion._obj)) {
+            throw new TypeError("Chai as Promised is incompatible with thenables of jQuery<3.0.0, sorry! Please " +
+                                "upgrade jQuery or use another Promises/A+ compatible library (see " +
+                                "http://promisesaplus.com/).");
+        }
     }
 
-    chaiAsPromised.transferPromiseness = function (assertion, promise) {
-        assertion.then = promise.then.bind(promise);
-    };
+    function method(name, asserter) {
+        utils.addMethod(Assertion.prototype, name, function () {
+            assertIsAboutPromise(this);
+            return asserter.apply(this, arguments);
+        });
+    }
 
-    chaiAsPromised.transformAsserterArgs = function (values) {
-        return values;
-    };
+    function property(name, asserter) {
+        utils.addProperty(Assertion.prototype, name, function () {
+            assertIsAboutPromise(this);
+            return asserter.apply(this, arguments);
+        });
+    }
 
-    function chaiAsPromised(chai, utils) {
-        var Assertion = chai.Assertion;
-        var assert = chai.assert;
-
-        function isLegacyJQueryPromise(thenable) {
-            // jQuery promises are Promises/A+-compatible since 3.0.0. jQuery 3.0.0 is also the first version
-            // to define the catch method.
-            return typeof thenable.catch !== "function" &&
-                   typeof thenable.always === "function" &&
-                   typeof thenable.done === "function" &&
-                   typeof thenable.fail === "function" &&
-                   typeof thenable.pipe === "function" &&
-                   typeof thenable.progress === "function" &&
-                   typeof thenable.state === "function";
-        }
+    function doNotify(promise, done) {
+        promise.then(function () { done(); }, done);
+    }
 
-        function assertIsAboutPromise(assertion) {
-            if (typeof assertion._obj.then !== "function") {
-                throw new TypeError(utils.inspect(assertion._obj) + " is not a thenable.");
-            }
-            if (isLegacyJQueryPromise(assertion._obj)) {
-                throw new TypeError("Chai as Promised is incompatible with thenables of jQuery<3.0.0, sorry! Please " +
-                                    "upgrade jQuery or use another Promises/A+ compatible library (see " +
-                                    "http://promisesaplus.com/).");
-            }
-        }
+    // These are for clarity and to bypass Chai refusing to allow `undefined` as actual when used with `assert`.
+    function assertIfNegated(assertion, message, extra) {
+        assertion.assert(true, null, message, extra.expected, extra.actual);
+    }
 
-        function method(name, asserter) {
-            utils.addMethod(Assertion.prototype, name, function () {
-                assertIsAboutPromise(this);
-                return asserter.apply(this, arguments);
-            });
-        }
+    function assertIfNotNegated(assertion, message, extra) {
+        assertion.assert(false, message, null, extra.expected, extra.actual);
+    }
 
-        function property(name, asserter) {
-            utils.addProperty(Assertion.prototype, name, function () {
-                assertIsAboutPromise(this);
-                return asserter.apply(this, arguments);
-            });
-        }
+    function getBasePromise(assertion) {
+        // We need to chain subsequent asserters on top of ones in the chain already (consider
+        // `eventually.have.property("foo").that.equals("bar")`), only running them after the existing ones pass.
+        // So the first base-promise is `assertion._obj`, but after that we use the assertions themselves, i.e.
+        // previously derived promises, to chain off of.
+        return typeof assertion.then === "function" ? assertion : assertion._obj;
+    }
 
-        function doNotify(promise, done) {
-            promise.then(function () { done(); }, done);
-        }
+    function getReasonName(reason) {
+        return (reason instanceof Error) ? reason.toString() : checkError.getConstructorName(reason);
+    }
 
-        // These are for clarity and to bypass Chai refusing to allow `undefined` as actual when used with `assert`.
-        function assertIfNegated(assertion, message, extra) {
-            assertion.assert(true, null, message, extra.expected, extra.actual);
+    // Grab these first, before we modify `Assertion.prototype`.
+
+    var propertyNames = Object.getOwnPropertyNames(Assertion.prototype);
+
+    var propertyDescs = {};
+    propertyNames.forEach(function (name) {
+        propertyDescs[name] = Object.getOwnPropertyDescriptor(Assertion.prototype, name);
+    });
+
+    property("fulfilled", function () {
+        var that = this;
+        var derivedPromise = getBasePromise(that).then(
+            function (value) {
+                assertIfNegated(that,
+                                "expected promise not to be fulfilled but it was fulfilled with #{act}",
+                                { actual: value });
+                return value;
+            },
+            function (reason) {
+                assertIfNotNegated(that,
+                                   "expected promise to be fulfilled but it was rejected with #{act}",
+                                   { actual: getReasonName(reason) });
+                return reason;
+            }
+        );
+
+        module.exports.transferPromiseness(that, derivedPromise);
+    });
+
+    property("rejected", function () {
+        var that = this;
+        var derivedPromise = getBasePromise(that).then(
+            function (value) {
+                assertIfNotNegated(that,
+                                   "expected promise to be rejected but it was fulfilled with #{act}",
+                                   { actual: value });
+                return value;
+            },
+            function (reason) {
+                assertIfNegated(that,
+                                "expected promise not to be rejected but it was rejected with #{act}",
+                                { actual: getReasonName(reason) });
+
+                // Return the reason, transforming this into a fulfillment, to allow further assertions, e.g.
+                // `promise.should.be.rejected.and.eventually.equal("reason")`.
+                return reason;
+            }
+        );
+
+        module.exports.transferPromiseness(that, derivedPromise);
+    });
+
+    method("rejectedWith", function (errorLike, errMsgMatcher, message) {
+        var errorLikeName = null;
+        var negate = utils.flag(this, "negate") || false;
+
+        // rejectedWith with that is called without arguments is
+        // the same as a plain ".rejected" use.
+        if (errorLike === undefined && errMsgMatcher === undefined &&
+            message === undefined) {
+            /* jshint expr: true */
+            this.rejected;
+            return;
         }
 
-        function assertIfNotNegated(assertion, message, extra) {
-            assertion.assert(false, message, null, extra.expected, extra.actual);
+        if (message !== undefined) {
+            utils.flag(this, "message", message);
         }
 
-        function getBasePromise(assertion) {
-            // We need to chain subsequent asserters on top of ones in the chain already (consider
-            // `eventually.have.property("foo").that.equals("bar")`), only running them after the existing ones pass.
-            // So the first base-promise is `assertion._obj`, but after that we use the assertions themselves, i.e.
-            // previously derived promises, to chain off of.
-            return typeof assertion.then === "function" ? assertion : assertion._obj;
+        if (errorLike instanceof RegExp || typeof errorLike === "string") {
+            errMsgMatcher = errorLike;
+            errorLike = null;
+        } else if (errorLike && errorLike instanceof Error) {
+            errorLikeName = errorLike.toString();
+        } else if (typeof errorLike === "function") {
+            errorLikeName = checkError.getConstructorName(errorLike);
+        } else {
+            errorLike = null;
         }
+        var everyArgIsDefined = Boolean(errorLike && errMsgMatcher);
 
-        // Grab these first, before we modify `Assertion.prototype`.
-
-        var propertyNames = Object.getOwnPropertyNames(Assertion.prototype);
-
-        var propertyDescs = {};
-        propertyNames.forEach(function (name) {
-            propertyDescs[name] = Object.getOwnPropertyDescriptor(Assertion.prototype, name);
-        });
+        var matcherRelation = "including";
+        if (errMsgMatcher instanceof RegExp) {
+            matcherRelation = "matching";
+        }
 
-        property("fulfilled", function () {
-            var that = this;
-            var derivedPromise = getBasePromise(that).then(
-                function (value) {
-                    that._obj = value;
-                    assertIfNegated(that,
-                                    "expected promise not to be fulfilled but it was fulfilled with #{act}",
-                                    { actual: value });
-                    return value;
-                },
-                function (reason) {
-                    assertIfNotNegated(that,
-                                       "expected promise to be fulfilled but it was rejected with #{act}",
-                                       { actual: reason });
+        var that = this;
+        var derivedPromise = getBasePromise(that).then(
+            function (value) {
+                var assertionMessage = null;
+                var expected = null;
+
+                if (errorLike) {
+                    assertionMessage = "expected promise to be rejected with #{exp} but it was fulfilled with " +
+                                       "#{act}";
+                    expected = errorLikeName;
+                } else if (errMsgMatcher) {
+                    assertionMessage = "expected promise to be rejected with an error " + matcherRelation +
+                        " #{exp} but it was fulfilled with #{act}";
+                    expected = errMsgMatcher;
                 }
-            );
-
-            chaiAsPromised.transferPromiseness(that, derivedPromise);
-        });
 
-        property("rejected", function () {
-            var that = this;
-            var derivedPromise = getBasePromise(that).then(
-                function (value) {
-                    that._obj = value;
-                    assertIfNotNegated(that,
-                                       "expected promise to be rejected but it was fulfilled with #{act}",
-                                       { actual: value });
-                    return value;
-                },
-                function (reason) {
-                    assertIfNegated(that,
-                                    "expected promise not to be rejected but it was rejected with #{act}",
-                                    { actual: reason });
-
-                    // Return the reason, transforming this into a fulfillment, to allow further assertions, e.g.
-                    // `promise.should.be.rejected.and.eventually.equal("reason")`.
-                    return reason;
-                }
-            );
-
-            chaiAsPromised.transferPromiseness(that, derivedPromise);
-        });
-
-        method("rejectedWith", function (Constructor, message) {
-            var desiredReason = null;
-            var constructorName = null;
-
-            if (Constructor instanceof RegExp || typeof Constructor === "string") {
-                message = Constructor;
-                Constructor = null;
-            } else if (Constructor && Constructor instanceof Error) {
-                desiredReason = Constructor;
-                Constructor = null;
-                message = null;
-            } else if (typeof Constructor === "function") {
-                constructorName = (new Constructor()).name;
-            } else {
-                Constructor = null;
-            }
-
-            var that = this;
-            var derivedPromise = getBasePromise(that).then(
-                function (value) {
-                    var assertionMessage = null;
-                    var expected = null;
-
-                    if (Constructor) {
-                        assertionMessage = "expected promise to be rejected with #{exp} but it was fulfilled with " +
-                                           "#{act}";
-                        expected = constructorName;
-                    } else if (message) {
-                        var verb = message instanceof RegExp ? "matching" : "including";
-                        assertionMessage = "expected promise to be rejected with an error " + verb + " #{exp} but it " +
-                                           "was fulfilled with #{act}";
-                        expected = message;
-                    } else if (desiredReason) {
-                        assertionMessage = "expected promise to be rejected with #{exp} but it was fulfilled with " +
-                                           "#{act}";
-                        expected = desiredReason;
+                assertIfNotNegated(that, assertionMessage, { expected: expected, actual: value });
+                return value;
+            },
+            function (reason) {
+                var errorLikeCompatible = errorLike && (errorLike instanceof Error ?
+                                                        checkError.compatibleInstance(reason, errorLike) :
+                                                        checkError.compatibleConstructor(reason, errorLike));
+
+                var errMsgMatcherCompatible = errMsgMatcher && checkError.compatibleMessage(reason, errMsgMatcher);
+
+                var reasonName = getReasonName(reason);
+
+                if (negate && everyArgIsDefined) {
+                    if (errorLikeCompatible && errMsgMatcherCompatible) {
+                        that.assert(true,
+                                    null,
+                                    "expected promise not to be rejected with #{exp} but it was rejected " +
+                                    "with #{act}",
+                                    errorLikeName,
+                                    reasonName);
                     }
-
-                    that._obj = value;
-
-                    assertIfNotNegated(that, assertionMessage, { expected: expected, actual: value });
-                },
-                function (reason) {
-                    if (Constructor) {
-                        that.assert(reason instanceof Constructor,
+                }
+                else {
+                    if (errorLike) {
+                        that.assert(errorLikeCompatible,
                                     "expected promise to be rejected with #{exp} but it was rejected with #{act}",
-                                    "expected promise not to be rejected with #{exp} but it was rejected with #{act}",
-                                    constructorName,
-                                    reason);
+                                    "expected promise not to be rejected with #{exp} but it was rejected " +
+                                    "with #{act}",
+                                    errorLikeName,
+                                    reasonName);
                     }
 
-                    var reasonMessage = utils.type(reason) === "object" && "message" in reason ?
-                                            reason.message :
-                                            "" + reason;
-                    if (message && reasonMessage !== null && reasonMessage !== undefined) {
-                        if (message instanceof RegExp) {
-                            that.assert(message.test(reasonMessage),
-                                        "expected promise to be rejected with an error matching #{exp} but got #{act}",
-                                        "expected promise not to be rejected with an error matching #{exp}",
-                                        message,
-                                        reasonMessage);
-                        }
-                        if (typeof message === "string") {
-                            that.assert(reasonMessage.indexOf(message) !== -1,
-                                        "expected promise to be rejected with an error including #{exp} but got #{act}",
-                                        "expected promise not to be rejected with an error including #{exp}",
-                                        message,
-                                        reasonMessage);
-                        }
-                    }
-
-                    if (desiredReason) {
-                        that.assert(reason === desiredReason,
-                                    "expected promise to be rejected with #{exp} but it was rejected with #{act}",
-                                    "expected promise not to be rejected with #{exp}",
-                                    desiredReason,
-                                    reason);
+                    if (errMsgMatcher) {
+                        that.assert(errMsgMatcherCompatible,
+                                    "expected promise to be rejected with an error " + matcherRelation +
+                                    " #{exp} but got #{act}",
+                                    "expected promise not to be rejected with an error " + matcherRelation +
+                                    " #{exp}",
+                                    errMsgMatcher,
+                                    checkError.getMessage(reason));
                     }
                 }
-            );
 
-            chaiAsPromised.transferPromiseness(that, derivedPromise);
-        });
+                return reason;
+            }
+        );
 
-        property("eventually", function () {
-            utils.flag(this, "eventually", true);
-        });
+        module.exports.transferPromiseness(that, derivedPromise);
+    });
 
-        method("notify", function (done) {
-            doNotify(getBasePromise(this), done);
-        });
+    property("eventually", function () {
+        utils.flag(this, "eventually", true);
+    });
 
-        method("become", function (value, message) {
-            return this.eventually.deep.equal(value, message);
-        });
+    method("notify", function (done) {
+        doNotify(getBasePromise(this), done);
+    });
 
-        ////////
-        // `eventually`
+    method("become", function (value, message) {
+        return this.eventually.deep.equal(value, message);
+    });
 
-        // We need to be careful not to trigger any getters, thus `Object.getOwnPropertyDescriptor` usage.
-        var methodNames = propertyNames.filter(function (name) {
-            return name !== "assert" && typeof propertyDescs[name].value === "function";
-        });
+    ////////
+    // `eventually`
 
-        methodNames.forEach(function (methodName) {
-            Assertion.overwriteMethod(methodName, function (originalMethod) {
-                return function () {
-                    doAsserterAsyncAndAddThen(originalMethod, this, arguments);
-                };
-            });
-        });
+    // We need to be careful not to trigger any getters, thus `Object.getOwnPropertyDescriptor` usage.
+    var methodNames = propertyNames.filter(function (name) {
+        return name !== "assert" && typeof propertyDescs[name].value === "function";
+    });
 
-        var getterNames = propertyNames.filter(function (name) {
-            return name !== "_obj" && typeof propertyDescs[name].get === "function";
+    methodNames.forEach(function (methodName) {
+        Assertion.overwriteMethod(methodName, function (originalMethod) {
+            return function () {
+                doAsserterAsyncAndAddThen(originalMethod, this, arguments);
+            };
         });
-
-        getterNames.forEach(function (getterName) {
-            // Chainable methods are things like `an`, which can work both for `.should.be.an.instanceOf` and as
-            // `should.be.an("object")`. We need to handle those specially.
-            var isChainableMethod = Assertion.prototype.__methods.hasOwnProperty(getterName);
-
-            if (isChainableMethod) {
-                Assertion.overwriteChainableMethod(
-                    getterName,
-                    function (originalMethod) {
-                        return function() {
-                            doAsserterAsyncAndAddThen(originalMethod, this, arguments);
-                        };
-                    },
-                    function (originalGetter) {
-                        return function() {
-                            doAsserterAsyncAndAddThen(originalGetter, this);
-                        };
-                    }
-                );
-            } else {
-                Assertion.overwriteProperty(getterName, function (originalGetter) {
-                    return function () {
+    });
+
+    var getterNames = propertyNames.filter(function (name) {
+        return name !== "_obj" && typeof propertyDescs[name].get === "function";
+    });
+
+    getterNames.forEach(function (getterName) {
+        // Chainable methods are things like `an`, which can work both for `.should.be.an.instanceOf` and as
+        // `should.be.an("object")`. We need to handle those specially.
+        var isChainableMethod = Assertion.prototype.__methods.hasOwnProperty(getterName);
+
+        if (isChainableMethod) {
+            Assertion.overwriteChainableMethod(
+                getterName,
+                function (originalMethod) {
+                    return function() {
+                        doAsserterAsyncAndAddThen(originalMethod, this, arguments);
+                    };
+                },
+                function (originalGetter) {
+                    return function() {
                         doAsserterAsyncAndAddThen(originalGetter, this);
                     };
-                });
-            }
-        });
-
-        function doAsserterAsyncAndAddThen(asserter, assertion, args) {
-            // Since we're intercepting all methods/properties, we need to just pass through if they don't want
-            // `eventually`, or if we've already fulfilled the promise (see below).
-            if (!utils.flag(assertion, "eventually")) {
-                return asserter.apply(assertion, args);
-            }
-
-            var derivedPromise = getBasePromise(assertion).then(function (value) {
-                // Set up the environment for the asserter to actually run: `_obj` should be the fulfillment value, and
-                // now that we have the value, we're no longer in "eventually" mode, so we won't run any of this code,
-                // just the base Chai code that we get to via the short-circuit above.
-                assertion._obj = value;
-                utils.flag(assertion, "eventually", false);
-
-                return args ? chaiAsPromised.transformAsserterArgs(args) : args;
-            }).then(function (args) {
-                asserter.apply(assertion, args);
-
-                // Because asserters, for example `property`, can change the value of `_obj` (i.e. change the "object"
-                // flag), we need to communicate this value change to subsequent chained asserters. Since we build a
-                // promise chain paralleling the asserter chain, we can use it to communicate such changes.
-                return assertion._obj;
+                }
+            );
+        } else {
+            Assertion.overwriteProperty(getterName, function (originalGetter) {
+                return function () {
+                    doAsserterAsyncAndAddThen(originalGetter, this);
+                };
             });
+        }
+    });
 
-            chaiAsPromised.transferPromiseness(assertion, derivedPromise);
+    function doAsserterAsyncAndAddThen(asserter, assertion, args) {
+        // Since we're intercepting all methods/properties, we need to just pass through if they don't want
+        // `eventually`, or if we've already fulfilled the promise (see below).
+        if (!utils.flag(assertion, "eventually")) {
+            return asserter.apply(assertion, args);
         }
 
-        ///////
-        // Now use the `Assertion` framework to build an `assert` interface.
-        var originalAssertMethods = Object.getOwnPropertyNames(assert).filter(function (propName) {
-            return typeof assert[propName] === "function";
+        var derivedPromise = getBasePromise(assertion).then(function (value) {
+            // Set up the environment for the asserter to actually run: `_obj` should be the fulfillment value, and
+            // now that we have the value, we're no longer in "eventually" mode, so we won't run any of this code,
+            // just the base Chai code that we get to via the short-circuit above.
+            assertion._obj = value;
+            utils.flag(assertion, "eventually", false);
+
+            return args ? module.exports.transformAsserterArgs(args) : args;
+        }).then(function (args) {
+            asserter.apply(assertion, args);
+
+            // Because asserters, for example `property`, can change the value of `_obj` (i.e. change the "object"
+            // flag), we need to communicate this value change to subsequent chained asserters. Since we build a
+            // promise chain paralleling the asserter chain, we can use it to communicate such changes.
+            return assertion._obj;
         });
 
-        assert.isFulfilled = function (promise, message) {
-            return (new Assertion(promise, message)).to.be.fulfilled;
-        };
-
-        assert.isRejected = function (promise, toTestAgainst, message) {
-            if (typeof toTestAgainst === "string") {
-                message = toTestAgainst;
-                toTestAgainst = undefined;
-            }
+        module.exports.transferPromiseness(assertion, derivedPromise);
+    }
 
-            var assertion = (new Assertion(promise, message));
-            return toTestAgainst !== undefined ? assertion.to.be.rejectedWith(toTestAgainst) : assertion.to.be.rejected;
-        };
+    ///////
+    // Now use the `Assertion` framework to build an `assert` interface.
+    var originalAssertMethods = Object.getOwnPropertyNames(assert).filter(function (propName) {
+        return typeof assert[propName] === "function";
+    });
 
-        assert.becomes = function (promise, value, message) {
-            return assert.eventually.deepEqual(promise, value, message);
-        };
+    assert.isFulfilled = function (promise, message) {
+        return (new Assertion(promise, message)).to.be.fulfilled;
+    };
 
-        assert.doesNotBecome = function (promise, value, message) {
-            return assert.eventually.notDeepEqual(promise, value, message);
-        };
+    assert.isRejected = function (promise, errorLike, errMsgMatcher, message) {
+        var assertion = (new Assertion(promise, message));
+        return assertion.to.be.rejectedWith(errorLike, errMsgMatcher, message);
+    };
 
-        assert.eventually = {};
-        originalAssertMethods.forEach(function (assertMethodName) {
-            assert.eventually[assertMethodName] = function (promise) {
-                var otherArgs = Array.prototype.slice.call(arguments, 1);
+    assert.becomes = function (promise, value, message) {
+        return assert.eventually.deepEqual(promise, value, message);
+    };
 
-                var customRejectionHandler;
-                var message = arguments[assert[assertMethodName].length - 1];
-                if (typeof message === "string") {
-                    customRejectionHandler = function (reason) {
-                        throw new chai.AssertionError(message + "\n\nOriginal reason: " + utils.inspect(reason));
-                    };
-                }
+    assert.doesNotBecome = function (promise, value, message) {
+        return assert.eventually.notDeepEqual(promise, value, message);
+    };
 
-                var returnedPromise = promise.then(
-                    function (fulfillmentValue) {
-                        return assert[assertMethodName].apply(assert, [fulfillmentValue].concat(otherArgs));
-                    },
-                    customRejectionHandler
-                );
+    assert.eventually = {};
+    originalAssertMethods.forEach(function (assertMethodName) {
+        assert.eventually[assertMethodName] = function (promise) {
+            var otherArgs = Array.prototype.slice.call(arguments, 1);
 
-                returnedPromise.notify = function (done) {
-                    doNotify(returnedPromise, done);
+            var customRejectionHandler;
+            var message = arguments[assert[assertMethodName].length - 1];
+            if (typeof message === "string") {
+                customRejectionHandler = function (reason) {
+                    throw new chai.AssertionError(message + "\n\nOriginal reason: " + utils.inspect(reason));
                 };
+            }
+
+            var returnedPromise = promise.then(
+                function (fulfillmentValue) {
+                    return assert[assertMethodName].apply(assert, [fulfillmentValue].concat(otherArgs));
+                },
+                customRejectionHandler
+            );
 
-                return returnedPromise;
+            returnedPromise.notify = function (done) {
+                doNotify(returnedPromise, done);
             };
-        });
-    }
-}());
+
+            return returnedPromise;
+        };
+    });
+};
+
+module.exports.transferPromiseness = function (assertion, promise) {
+    assertion.then = promise.then.bind(promise);
+};
+
+module.exports.transformAsserterArgs = function (values) {
+    return values;
+};

package/package.json

@@ -11,7 +11,7 @@
     "promises",
     "promises-aplus"
   ],
-  "version": "5.3.0",
+  "version": "6.0.0",
   "author": "Domenic Denicola <d@domenic.me> (https://domenic.me)",
   "license": "WTFPL",
   "repository": "domenic/chai-as-promised",
@@ -23,21 +23,21 @@
     "test": "npm run test-plugin && npm run test-intercompatibility",
     "test-plugin": "mocha",
     "test-intercompatibility": "mocha test-intercompatibility --opts test-intercompatibility/mocha.opts",
-    "test-browser-jquery": "coffee ./test/browser/runner.coffee jquery",
-    "test-browser-q": "coffee ./test/browser/runner.coffee q",
-    "test-browser-when": "coffee ./test/browser/runner.coffee when",
     "lint": "jshint ./lib",
     "cover": "istanbul cover node_modules/mocha/bin/_mocha && opener ./coverage/lcov-report/lib/chai-as-promised.js.html"
   },
+  "dependencies": {
+    "check-error": "^1.0.2"
+  },
   "peerDependencies": {
     "chai": ">= 2.1.2 < 4"
   },
   "devDependencies": {
     "chai": "^3.0.0",
     "coffee-script": "1.10.0",
-    "istanbul": "0.4.1",
     "ecstatic": "^1.3.1",
     "glob": "^6.0.1",
+    "istanbul": "0.4.1",
     "jshint": "^2.8.0",
     "mocha": "^2.3.4",
     "opener": "^1.4.1",