chai-as-promised 5.3.0 → 7.1.1

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

@@ -5,7 +5,7 @@
 
 # Chai Assertions for Promises
 
-**Chai as Promised** extends [Chai][chai] with a fluent language for asserting facts about [promises][presentation].
+**Chai as Promised** extends [Chai](http://chaijs.com/) with a fluent language for asserting facts about [promises](http://www.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript).
 
 Instead of manually wiring up your expectations to a promise's fulfilled and rejected handlers:
 
@@ -90,7 +90,7 @@ return assert.isRejected(promise, /error message matcher/, "optional message");
 
 ### Progress Callbacks
 
-Chai as Promised does not have any intrinsic support for testing promise progress callbacks. The properties you would want to test are probably much better suited to a library like [Sinon.JS][sinon], perhaps in conjunction with [Sinon–Chai][sinon-chai]:
+Chai as Promised does not have any intrinsic support for testing promise progress callbacks. The properties you would want to test are probably much better suited to a library like [Sinon.JS](http://sinonjs.org/), perhaps in conjunction with [Sinon–Chai](https://github.com/domenic/sinon-chai):
 
 ```javascript
 var progressSpy = sinon.spy();
@@ -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,11 +144,15 @@ 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](http://promisesaplus.com/).
+
+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](http://domenic.me/2012/10/14/youre-missing-the-point-of-promises/#toc_2) 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
 
-Some test runners (e.g. Jasmine, QUnit, or tap/tape) do not have the ability to use the returned promise to signal asynchronous test completion. If possible, I'd recommend switching to ones that do, such as [Mocha][mocha-promises], [Buster][buster-promises], or [blue-tape][]. But if that's not an option, Chai as Promised still has you covered. As long as your test framework takes a callback indicating when the asynchronous test run is over, Chai as Promised can adapt to that situation with its `notify` method, like so:
+Some test runners (e.g. Jasmine, QUnit, or tap/tape) do not have the ability to use the returned promise to signal asynchronous test completion. If possible, I'd recommend switching to ones that do, such as [Mocha](http://mochajs.org/#asynchronous-code), [Buster](http://docs.busterjs.org/en/latest/modules/buster-test/spec/#returning-a-promise), or [blue-tape](https://github.com/spion/blue-tape). But if that's not an option, Chai as Promised still has you covered. As long as your test framework takes a callback indicating when the asynchronous test run is over, Chai as Promised can adapt to that situation with its `notify` method, like so:
 
 ```javascript
 it("should be fulfilled", function (done) {
@@ -202,51 +206,28 @@ 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
 ```
 
-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].
+You can of course put this code in a common test fixture file; for an example using [Mocha](http://mochajs.org), see [the Chai as Promised tests themselves](https://github.com/domenic/chai-as-promised/tree/master/test/).
 
-### AMD
+**Note when using other Chai plugins:** Chai as Promised finds all currently-registered asserters and promisifies them, at the time it is installed. Thus, you should install Chai as Promised _last_, after any other Chai plugins, if you expect their asserters to be promisified.
 
-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:
+### In the Browser
 
-```javascript
-define(function (require, exports, module) {
-    var chai = require("chai");
-    var chaiAsPromised = require("chai-as-promised");
+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](http://browserify.org/). See also the note below about browser compatibility.
 
-    chai.use(chaiAsPromised);
-});
-```
-
-### `<script>` tag
+### Karma
 
-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:
+If you're using [Karma](https://karma-runner.github.io/), check out the accompanying [karma-chai-as-promised](https://github.com/vlkosinov/karma-chai-as-promised) plugin.
 
-```html
-<script src="chai.js"></script>
-<script src="chai-as-promised.js"></script>
-```
-
-### Karma
+### Browser/Node Compatibility
 
-If you're using [Karma][], check out the accompanying [karma-chai-as-promised][] plugin.
-
-### Browser Compatibility
-
-Chai as Promised is only compatible with modern browsers (IE ≥9, Safari ≥6, no PhantomJS).
-
-[presentation]: http://www.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript
-[chai]: http://chaijs.com/
-[Mocha-promises]: http://mochajs.org/#asynchronous-code
-[Buster-promises]: http://docs.busterjs.org/en/latest/modules/buster-test/spec/#returning-a-promise
-[blue-tape]: https://github.com/spion/blue-tape
-[spec]: http://promisesaplus.com/
-[transformation behavior]: http://domenic.me/2012/10/14/youre-missing-the-point-of-promises/#toc_2
-[Mocha]: http://mochajs.org
-[fixturedemo]: https://github.com/domenic/chai-as-promised/tree/master/test/
-[amd]: https://github.com/amdjs/amdjs-api/wiki/AMD
-[sinon]: http://sinonjs.org/
-[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
+Chai as Promised requires Node v4+ or a browser with equivalent support for modern JavaScript syntax. If your browser doesn't support modern JavaScript syntax, you'll need to transpile it down using a tool like [Babel](http://babeljs.io/).

package/lib/chai-as-promised.js

@@ -1,375 +1,361 @@
-(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 */
-
-        // Other environment (usually <script> tag): plug in to global chai instance directly.
-        chai.use(chaiAsPromised);
-
-        // Expose as a property of the global object so that consumers can configure the `transferPromiseness` property.
-        self.chaiAsPromised = chaiAsPromised;
+"use strict";
+/* eslint-disable no-invalid-this */
+let checkError = require("check-error");
+
+module.exports = (chai, utils) => {
+    const Assertion = chai.Assertion;
+    const assert = chai.assert;
+    const proxify = utils.proxify;
+
+    // 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;
     }
 
-    chaiAsPromised.transferPromiseness = function (assertion, promise) {
-        assertion.then = promise.then.bind(promise);
-    };
-
-    chaiAsPromised.transformAsserterArgs = function (values) {
-        return values;
-    };
+    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 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 assertIsAboutPromise(assertion) {
+        if (typeof assertion._obj.then !== "function") {
+            throw new TypeError(utils.inspect(assertion._obj) + " is not a thenable.");
         }
-
-        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/).");
-            }
+        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/).");
         }
+    }
 
-        function method(name, asserter) {
-            utils.addMethod(Assertion.prototype, name, function () {
-                assertIsAboutPromise(this);
-                return asserter.apply(this, arguments);
-            });
-        }
+    function proxifyIfSupported(assertion) {
+        return proxify === undefined ? assertion : proxify(assertion);
+    }
 
-        function property(name, asserter) {
-            utils.addProperty(Assertion.prototype, name, function () {
-                assertIsAboutPromise(this);
-                return asserter.apply(this, arguments);
-            });
-        }
+    function method(name, asserter) {
+        utils.addMethod(Assertion.prototype, name, function () {
+            assertIsAboutPromise(this);
+            return asserter.apply(this, arguments);
+        });
+    }
 
-        function doNotify(promise, done) {
-            promise.then(function () { done(); }, done);
-        }
+    function property(name, asserter) {
+        utils.addProperty(Assertion.prototype, name, function () {
+            assertIsAboutPromise(this);
+            return proxifyIfSupported(asserter.apply(this, arguments));
+        });
+    }
 
-        // 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 doNotify(promise, done) {
+        promise.then(() => done(), done);
+    }
 
-        function assertIfNotNegated(assertion, message, extra) {
-            assertion.assert(false, message, null, extra.expected, extra.actual);
-        }
+    // 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 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 assertIfNotNegated(assertion, message, extra) {
+        assertion.assert(false, message, null, extra.expected, extra.actual);
+    }
 
-        // Grab these first, before we modify `Assertion.prototype`.
+    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;
+    }
 
-        var propertyNames = Object.getOwnPropertyNames(Assertion.prototype);
+    function getReasonName(reason) {
+        return reason instanceof Error ? reason.toString() : checkError.getConstructorName(reason);
+    }
 
-        var propertyDescs = {};
-        propertyNames.forEach(function (name) {
-            propertyDescs[name] = Object.getOwnPropertyDescriptor(Assertion.prototype, name);
-        });
+    // Grab these first, before we modify `Assertion.prototype`.
 
-        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 });
-                }
-            );
+    const propertyNames = Object.getOwnPropertyNames(Assertion.prototype);
 
-            chaiAsPromised.transferPromiseness(that, derivedPromise);
-        });
+    const propertyDescs = {};
+    for (const name of propertyNames) {
+        propertyDescs[name] = Object.getOwnPropertyDescriptor(Assertion.prototype, name);
+    }
 
-        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;
-                }
-            );
+    property("fulfilled", function () {
+        const derivedPromise = getBasePromise(this).then(
+            value => {
+                assertIfNegated(this,
+                                "expected promise not to be fulfilled but it was fulfilled with #{act}",
+                                { actual: value });
+                return value;
+            },
+            reason => {
+                assertIfNotNegated(this,
+                                   "expected promise to be fulfilled but it was rejected with #{act}",
+                                   { actual: getReasonName(reason) });
+                return reason;
+            }
+        );
+
+        module.exports.transferPromiseness(this, derivedPromise);
+        return this;
+    });
+
+    property("rejected", function () {
+        const derivedPromise = getBasePromise(this).then(
+            value => {
+                assertIfNotNegated(this,
+                                   "expected promise to be rejected but it was fulfilled with #{act}",
+                                   { actual: value });
+                return value;
+            },
+            reason => {
+                assertIfNegated(this,
+                                "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(this, derivedPromise);
+        return this;
+    });
+
+    method("rejectedWith", function (errorLike, errMsgMatcher, message) {
+        let errorLikeName = null;
+        const 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) {
+            /* eslint-disable no-unused-expressions */
+            return this.rejected;
+            /* eslint-enable no-unused-expressions */
+        }
 
-            chaiAsPromised.transferPromiseness(that, derivedPromise);
-        });
+        if (message !== undefined) {
+            utils.flag(this, "message", message);
+        }
 
-        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;
-            }
+        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;
+        }
+        const everyArgIsDefined = Boolean(errorLike && errMsgMatcher);
 
-            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;
-                    }
+        let matcherRelation = "including";
+        if (errMsgMatcher instanceof RegExp) {
+            matcherRelation = "matching";
+        }
 
-                    that._obj = value;
+        const derivedPromise = getBasePromise(this).then(
+            value => {
+                let assertionMessage = null;
+                let 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;
+                }
 
-                    assertIfNotNegated(that, assertionMessage, { expected: expected, actual: value });
-                },
-                function (reason) {
-                    if (Constructor) {
-                        that.assert(reason instanceof Constructor,
-                                    "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);
+                assertIfNotNegated(this, assertionMessage, { expected, actual: value });
+                return value;
+            },
+            reason => {
+                const errorLikeCompatible = errorLike && (errorLike instanceof Error ?
+                                                        checkError.compatibleInstance(reason, errorLike) :
+                                                        checkError.compatibleConstructor(reason, errorLike));
+
+                const errMsgMatcherCompatible = errMsgMatcher && checkError.compatibleMessage(reason, errMsgMatcher);
+
+                const reasonName = getReasonName(reason);
+
+                if (negate && everyArgIsDefined) {
+                    if (errorLikeCompatible && errMsgMatcherCompatible) {
+                        this.assert(true,
+                                    null,
+                                    "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);
-                        }
+                } else {
+                    if (errorLike) {
+                        this.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}",
+                                    errorLikeName,
+                                    reasonName);
                     }
 
-                    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) {
+                        this.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(this, derivedPromise);
+        return this;
+    });
 
-        method("notify", function (done) {
-            doNotify(getBasePromise(this), done);
-        });
+    property("eventually", function () {
+        utils.flag(this, "eventually", true);
+        return this;
+    });
 
-        method("become", function (value, message) {
-            return this.eventually.deep.equal(value, message);
-        });
+    method("notify", function (done) {
+        doNotify(getBasePromise(this), done);
+        return this;
+    });
 
-        ////////
-        // `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.
+    const methodNames = propertyNames.filter(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(methodName => {
+        Assertion.overwriteMethod(methodName, originalMethod => function () {
+            return 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 () {
-                        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;
+    });
+
+    const getterNames = propertyNames.filter(name => {
+        return name !== "_obj" && typeof propertyDescs[name].get === "function";
+    });
+
+    getterNames.forEach(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.
+        const isChainableMethod = Assertion.prototype.__methods.hasOwnProperty(getterName);
+
+        if (isChainableMethod) {
+            Assertion.overwriteChainableMethod(
+                getterName,
+                originalMethod => function () {
+                    return doAsserterAsyncAndAddThen(originalMethod, this, arguments);
+                },
+                originalGetter => function () {
+                    return doAsserterAsyncAndAddThen(originalGetter, this);
+                }
+            );
+        } else {
+            Assertion.overwriteProperty(getterName, originalGetter => function () {
+                return proxifyIfSupported(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")) {
+            asserter.apply(assertion, args);
+            return assertion;
         }
 
-        ///////
-        // Now use the `Assertion` framework to build an `assert` interface.
-        var originalAssertMethods = Object.getOwnPropertyNames(assert).filter(function (propName) {
-            return typeof assert[propName] === "function";
+        const derivedPromise = getBasePromise(assertion).then(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(newArgs => {
+            asserter.apply(assertion, newArgs);
+
+            // 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;
-        };
+        module.exports.transferPromiseness(assertion, derivedPromise);
+        return assertion;
+    }
 
-        assert.isRejected = function (promise, toTestAgainst, message) {
-            if (typeof toTestAgainst === "string") {
-                message = toTestAgainst;
-                toTestAgainst = undefined;
-            }
+    // ### Now use the `Assertion` framework to build an `assert` interface.
+    const originalAssertMethods = Object.getOwnPropertyNames(assert).filter(propName => {
+        return typeof assert[propName] === "function";
+    });
 
-            var assertion = (new Assertion(promise, message));
-            return toTestAgainst !== undefined ? assertion.to.be.rejectedWith(toTestAgainst) : assertion.to.be.rejected;
-        };
+    assert.isFulfilled = (promise, message) => (new Assertion(promise, message)).to.be.fulfilled;
 
-        assert.becomes = function (promise, value, message) {
-            return assert.eventually.deepEqual(promise, value, message);
-        };
+    assert.isRejected = (promise, errorLike, errMsgMatcher, message) => {
+        const assertion = new Assertion(promise, message);
+        return assertion.to.be.rejectedWith(errorLike, errMsgMatcher, message);
+    };
 
-        assert.doesNotBecome = function (promise, value, message) {
-            return assert.eventually.notDeepEqual(promise, value, message);
-        };
+    assert.becomes = (promise, value, message) => assert.eventually.deepEqual(promise, value, message);
 
-        assert.eventually = {};
-        originalAssertMethods.forEach(function (assertMethodName) {
-            assert.eventually[assertMethodName] = function (promise) {
-                var otherArgs = Array.prototype.slice.call(arguments, 1);
-
-                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 = (promise, value, message) => 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(assertMethodName => {
+        assert.eventually[assertMethodName] = function (promise) {
+            const otherArgs = Array.prototype.slice.call(arguments, 1);
 
-                returnedPromise.notify = function (done) {
-                    doNotify(returnedPromise, done);
+            let customRejectionHandler;
+            const message = arguments[assert[assertMethodName].length - 1];
+            if (typeof message === "string") {
+                customRejectionHandler = reason => {
+                    throw new chai.AssertionError(`${message}\n\nOriginal reason: ${utils.inspect(reason)}`);
                 };
+            }
 
-                return returnedPromise;
+            const returnedPromise = promise.then(
+                fulfillmentValue => assert[assertMethodName].apply(assert, [fulfillmentValue].concat(otherArgs)),
+                customRejectionHandler
+            );
+
+            returnedPromise.notify = done => {
+                doNotify(returnedPromise, done);
             };
-        });
-    }
-}());
+
+            return returnedPromise;
+        };
+    });
+};
+
+module.exports.transferPromiseness = (assertion, promise) => {
+    assertion.then = promise.then.bind(promise);
+};
+
+module.exports.transformAsserterArgs = values => values;

package/package.json

@@ -11,7 +11,7 @@
     "promises",
     "promises-aplus"
   ],
-  "version": "5.3.0",
+  "version": "7.1.1",
   "author": "Domenic Denicola <d@domenic.me> (https://domenic.me)",
   "license": "WTFPL",
   "repository": "domenic/chai-as-promised",
@@ -20,28 +20,21 @@
     "lib"
   ],
   "scripts": {
-    "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",
+    "test": "mocha",
+    "test-travis": "npm install chai@$CHAI_VERSION && npm test",
+    "lint": "eslint .",
     "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"
+    "chai": ">= 2.1.2 < 5"
   },
   "devDependencies": {
-    "chai": "^3.0.0",
-    "coffee-script": "1.10.0",
-    "istanbul": "0.4.1",
-    "ecstatic": "^1.3.1",
-    "glob": "^6.0.1",
-    "jshint": "^2.8.0",
-    "mocha": "^2.3.4",
-    "opener": "^1.4.1",
-    "q": "^1.4.1",
-    "underscore": "1.8.3"
+    "chai": "^4.0.2",
+    "eslint": "^3.19.0",
+    "istanbul": "0.4.5",
+    "mocha": "^3.4.2"
   }
 }