chai-as-promised 4.0.0 → 4.3.0

package/LICENSE.txt

@@ -1,7 +1,13 @@
-            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+Copyright © 2012–2015 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,
+as published by Sam Hocevar. See below for more details.
+
+        DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
                     Version 2, December 2004
 
- Copyright © 2012–2013 Domenic Denicola <domenic@domenicdenicola.com>
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
 
  Everyone is permitted to copy and distribute verbatim or modified
  copies of this license document, and changing it is allowed as long
@@ -11,4 +17,3 @@
    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 
   0. You just DO WHAT THE FUCK YOU WANT TO.
-

package/README.md

@@ -1,5 +1,5 @@
-<a href="http://promises-aplus.github.com/promises-spec">
-    <img src="http://promises-aplus.github.com/promises-spec/assets/logo-small.png"
+<a href="http://promisesaplus.com/">
+    <img src="https://promises-aplus.github.io/promises-spec/assets/logo-small.png"
          align="right" valign="top" alt="Promises/A+ logo" />
 </a>
 
@@ -24,14 +24,14 @@ doSomethingAsync().then(
 you can write code that expresses what you really mean:
 
 ```javascript
-doSomethingAsync().should.eventually.equal("foo").notify(done);
+return doSomethingAsync().should.eventually.equal("foo");
 ```
 
-or if you have a testing framework that follows the [UncommonJS specification][uncommonjs] for handling promises,
-simply
+or if you have a testing framework that doesn't allow returning promises to signal asynchronous test completion, then
+you can use the following workaround:
 
 ```javascript
-return doSomethingAsync().should.eventually.equal("foo");
+doSomethingAsync().should.eventually.equal("foo").notify(done);
 ```
 
 ## How to Use
@@ -45,13 +45,13 @@ existing Chai assertion into one that acts on a promise:
 (2 + 2).should.equal(4);
 
 // becomes
-return promiseFor(2 + 2).should.eventually.equal(4);
+return Promise.resolve(2 + 2).should.eventually.equal(4);
 
 
 expect({ foo: "bar" }).to.have.property("foo");
 
 // becomes
-return expect(promiseFor({ foo: "bar" })).to.eventually.have.property("foo");
+return expect(Promise.resolve({ foo: "bar" })).to.eventually.have.property("foo");
 ```
 
 There are also a few promise-specific extensions (with the usual `expect` equivalents also available):
@@ -73,7 +73,7 @@ any existing Chai assertion to be used on a promise:
 assert.equal(2 + 2, 4, "This had better be true");
 
 // becomes
-return assert.eventually.equal(promiseFor(2 + 2), 4, "This had better be true, eventually");
+return assert.eventually.equal(Promise.resolve(2 + 2), 4, "This had better be true, eventually");
 ```
 
 And there are, of course, promise-specific extensions:
@@ -105,11 +105,65 @@ return promise.then(null, null, progressSpy).then(function () {
 });
 ```
 
+### Customizing Output Promises
+
+By default, the promises returned by Chai as Promised's assertions are regular Chai assertion objects, extended with
+a single `then` method derived from the input promise. To change this behavior, for instance to output a promise with
+more useful sugar methods such as are found in most promise libraries, you can override
+`chaiAsPromised.transferPromiseness`. Here's an example that transfer's Q's `finally` and `done` methods:
+
+```js
+chaiAsPromised.transferPromiseness = function (assertion, promise) {
+    assertion.then = promise.then.bind(promise); // this is all you get by default
+    assertion.finally = promise.finally.bind(promise);
+    assertion.done = promise.done.bind(promise);
+};
+```
+
+### Transforming Arguments to the Asserters
+
+Another advanced customization hook Chai as Promised allows is if you want to transform the arguments to the
+asserters, possibly asynchronously. Here is a toy example:
+
+```js
+chaiAsPromised.transformAsserterArgs = function (args) {
+    return args.map(function (x) { return x + 1; });
+}
+
+Promise.resolve(2).should.eventually.equal(2); // will now fail!
+Promise.resolve(2).should.eventually.equal(3); // 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:
+
+```js
+// This will normally fail, since within() only works on numbers.
+Promise.resolve(2).should.eventually.be.within(Promise.resolve(1), Promise.resolve(6));
+
+chaiAsPromised.transformAsserterArgs = function (args) {
+    return Promise.all(args);
+};
+
+// But now it will pass, since we transformed the array of promises for numbers into
+// (a promise for) an array of numbers
+Promise.resolve(2).should.eventually.be.within(Promise.resolve(1), Promise.resolve(6));
+```
+
+### Compatibility
+
+Chai as Promised is compatible with all promises following the [Promises/A+ specification][spec]. Notably, jQuery's
+so-called “promises” are not up to spec, 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 does not support.
+
 ### Working with Non-Promise–Friendly Test Runners
 
-As mentioned, many test runners (\*cough\* [Mocha][mocha-makes-me-sad] \*cough\* … but see [Mocha as Promised][]!)
-don't support the nice `return` style shown above. Instead, they take a callback indicating when the asynchronous test
-run is over. Chai as Promised adapts to this situation with the `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][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:
 
 ```javascript
 it("should be fulfilled", function (done) {
@@ -158,12 +212,6 @@ This will pass any failures of the individual promise assertions up to the test
 an `"expected promise to be fulfilled…"` message as would happen if you did
 `Q.all([…]).should.be.fulfilled.and.notify(done)`.
 
-### Compatibility
-
-Chai as Promised is compatible with all promises following the [Promises/A+ specification][spec]. Notably, jQuery's
-so-called “promises” are not up to spec, 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 does not support.
-
 ## Installation and Setup
 
 ### Node
@@ -177,7 +225,7 @@ 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][mocha], see
+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
@@ -205,15 +253,18 @@ automatically plug in to Chai and be ready for use:
 <script src="chai-as-promised.js"></script>
 ```
 
+### 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]: http://visionmedia.github.com/mocha/
-[mocha-makes-me-sad]: https://github.com/visionmedia/mocha/pull/329
-[Mocha as Promised]: https://github.com/domenic/mocha-as-promised
-[uncommonjs]: http://kriskowal.github.com/uncommonjs/tests/specification
-[spec]: http://promises-aplus.github.com/promises-spec/
-[transformation behavior]: https://gist.github.com/3889970#that-second-paragraph
+[Mocha-promises]: http://visionmedia.github.io/mocha/#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://visionmedia.github.com/mocha/
 [fixturedemo]: https://github.com/domenic/chai-as-promised/tree/master/test/
 [amd]: https://github.com/amdjs/amdjs-api/wiki/AMD
 [sinon]: http://sinonjs.org/

package/lib/chai-as-promised.js

@@ -1,8 +1,9 @@
-(function (chaiAsPromised) {
+(function () {
     "use strict";
 
     // Module systems magic dance.
 
+    /* istanbul ignore else */
     if (typeof require === "function" && typeof exports === "object" && typeof module === "object") {
         // NodeJS
         module.exports = chaiAsPromised;
@@ -12,346 +13,365 @@
             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;
     }
-}(function chaiAsPromised(chai, utils) {
-    "use strict";
 
-    var Assertion = chai.Assertion;
-    var assert = chai.assert;
+    chaiAsPromised.transferPromiseness = function (assertion, promise) {
+        assertion.then = promise.then.bind(promise);
+    };
 
-    function isJQueryPromise(thenable) {
-        return typeof thenable.always === "function" &&
-               typeof thenable.done === "function" &&
-               typeof thenable.fail === "function" &&
-               typeof thenable.pipe === "function" &&
-               typeof thenable.progress === "function" &&
-               typeof thenable.state === "function";
-    }
+    chaiAsPromised.transformAsserterArgs = function (values) {
+        return values;
+    };
 
-    function assertIsAboutPromise(assertion) {
-        if (typeof assertion._obj.then !== "function") {
-            throw new TypeError(utils.inspect(assertion._obj) + " is not a thenable.");
+    function chaiAsPromised(chai, utils) {
+        var Assertion = chai.Assertion;
+        var assert = chai.assert;
+
+        function isJQueryPromise(thenable) {
+            return typeof thenable.always === "function" &&
+                   typeof thenable.done === "function" &&
+                   typeof thenable.fail === "function" &&
+                   typeof thenable.pipe === "function" &&
+                   typeof thenable.progress === "function" &&
+                   typeof thenable.state === "function";
         }
-        if (isJQueryPromise(assertion._obj)) {
-            throw new TypeError("Chai as Promised is incompatible with jQuery's thenables, sorry! Please use a " +
-                                "Promises/A+ compatible library (see http://promisesaplus.com/).");
+
+        function assertIsAboutPromise(assertion) {
+            if (typeof assertion._obj.then !== "function") {
+                throw new TypeError(utils.inspect(assertion._obj) + " is not a thenable.");
+            }
+            if (isJQueryPromise(assertion._obj)) {
+                throw new TypeError("Chai as Promised is incompatible with jQuery's thenables, sorry! Please use a " +
+                                    "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 method(name, asserter) {
+            utils.addMethod(Assertion.prototype, name, function () {
+                assertIsAboutPromise(this);
+                return asserter.apply(this, arguments);
+            });
+        }
 
-    function property(name, asserter) {
-        utils.addProperty(Assertion.prototype, name, function () {
-            assertIsAboutPromise(this);
-            return asserter.apply(this, arguments);
-        });
-    }
+        function property(name, asserter) {
+            utils.addProperty(Assertion.prototype, name, function () {
+                assertIsAboutPromise(this);
+                return asserter.apply(this, arguments);
+            });
+        }
 
-    function doNotify(promise, done) {
-        promise.then(function () { done(); }, done);
-    }
+        function doNotify(promise, done) {
+            promise.then(function () { done(); }, done);
+        }
 
-    // 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);
-    }
+        // 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 assertIfNotNegated(assertion, message, extra) {
-        assertion.assert(false, message, null, extra.expected, extra.actual);
-    }
+        function assertIfNotNegated(assertion, message, extra) {
+            assertion.assert(false, message, null, 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 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;
+        }
 
-    // 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) {
-                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 });
-            });
+        // Grab these first, before we modify `Assertion.prototype`.
 
-        that.then = derivedPromise.then.bind(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;
-            }
-        );
-
-        that.then = derivedPromise.then.bind(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 propertyNames = Object.getOwnPropertyNames(Assertion.prototype);
 
-        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;
-                }
+        var propertyDescs = {};
+        propertyNames.forEach(function (name) {
+            propertyDescs[name] = Object.getOwnPropertyDescriptor(Assertion.prototype, name);
+        });
 
-                that._obj = value;
-
-                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);
+        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 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);
-                    }
-                }
+            chaiAsPromised.transferPromiseness(that, derivedPromise);
+        });
 
-                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);
+        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;
                 }
-            }
-        );
+            );
 
-        that.then = derivedPromise.then.bind(derivedPromise);
-    });
+            chaiAsPromised.transferPromiseness(that, derivedPromise);
+        });
 
-    property("eventually", function () {
-        utils.flag(this, "eventually", true);
-    });
+        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;
+            }
 
-    method("notify", function (done) {
-        doNotify(getBasePromise(this), done);
-    });
+            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;
+                    }
 
-    method("become", function (value) {
-        return this.eventually.deep.equal(value);
-    });
+                    that._obj = value;
 
-    ////////
-    // `eventually`
+                    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);
+                    }
 
-    // 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 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);
+                        }
+                    }
 
-    methodNames.forEach(function (methodName) {
-        Assertion.overwriteMethod(methodName, function (originalMethod) {
-            return function () {
-                doAsserterAsyncAndAddThen(originalMethod, this, arguments);
-            };
-        });
-    });
-
-    var getterNames = propertyNames.filter(function (name) {
-        return name !== "_obj" && typeof propertyDescs[name].get === "function";
-    });
-
-    getterNames.forEach(function (getterName) {
-        var propertyDesc = propertyDescs[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 = false;
-        try {
-            isChainableMethod = typeof propertyDesc.get.call({}) === "function";
-        } catch (e) { }
-
-        if (isChainableMethod) {
-            Assertion.addChainableMethod(
-                getterName,
-                function () {
-                    var assertion = this;
-                    function originalMethod() {
-                        return propertyDesc.get.call(assertion).apply(assertion, arguments);
+                    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);
                     }
-                    doAsserterAsyncAndAddThen(originalMethod, this, arguments);
-                },
-                function () {
-                    var originalGetter = propertyDesc.get;
-                    doAsserterAsyncAndAddThen(originalGetter, this);
                 }
             );
-        } else {
-            Assertion.overwriteProperty(getterName, function (originalGetter) {
+
+            chaiAsPromised.transferPromiseness(that, derivedPromise);
+        });
+
+        property("eventually", function () {
+            utils.flag(this, "eventually", true);
+        });
+
+        method("notify", function (done) {
+            doNotify(getBasePromise(this), done);
+        });
+
+        method("become", function (value) {
+            return this.eventually.deep.equal(value);
+        });
+
+        ////////
+        // `eventually`
+
+        // 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";
+        });
+
+        methodNames.forEach(function (methodName) {
+            Assertion.overwriteMethod(methodName, function (originalMethod) {
                 return function () {
-                    doAsserterAsyncAndAddThen(originalGetter, this);
+                    doAsserterAsyncAndAddThen(originalMethod, this, arguments);
                 };
             });
-        }
-    });
-
-    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);
-            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;
+        var getterNames = propertyNames.filter(function (name) {
+            return name !== "_obj" && typeof propertyDescs[name].get === "function";
         });
 
-        assertion.then = derivedPromise.then.bind(derivedPromise);
-    }
+        getterNames.forEach(function (getterName) {
+            var propertyDesc = propertyDescs[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 = false;
+            try {
+                isChainableMethod = typeof propertyDesc.get.call({}) === "function";
+            } catch (e) { }
+
+            if (isChainableMethod) {
+                Assertion.addChainableMethod(
+                    getterName,
+                    function () {
+                        var assertion = this;
+                        function originalMethod() {
+                            return propertyDesc.get.call(assertion).apply(assertion, arguments);
+                        }
+                        doAsserterAsyncAndAddThen(originalMethod, this, arguments);
+                    },
+                    function () {
+                        var originalGetter = propertyDesc.get;
+                        doAsserterAsyncAndAddThen(originalGetter, this);
+                    }
+                );
+            } else {
+                Assertion.overwriteProperty(getterName, function (originalGetter) {
+                    return function () {
+                        doAsserterAsyncAndAddThen(originalGetter, this);
+                    };
+                });
+            }
+        });
 
-    ///////
-    // Now use the `Assertion` framework to build an `assert` interface.
-    var originalAssertMethods = Object.getOwnPropertyNames(assert).filter(function (propName) {
-        return typeof assert[propName] === "function";
-    });
+        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);
+            }
 
-    assert.isFulfilled = function (promise, message) {
-        return (new Assertion(promise, message)).to.be.fulfilled;
-    };
+            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;
+            });
 
-    assert.isRejected = function (promise, toTestAgainst, message) {
-        if (typeof toTestAgainst === "string") {
-            message = toTestAgainst;
-            toTestAgainst = undefined;
+            chaiAsPromised.transferPromiseness(assertion, derivedPromise);
         }
 
-        var assertion = (new Assertion(promise, message));
-        return toTestAgainst !== undefined ? assertion.to.be.rejectedWith(toTestAgainst) : assertion.to.be.rejected;
-    };
-
-    assert.becomes = function (promise, value) {
-        return assert.eventually.deepEqual(promise, value);
-    };
-
-    assert.doesNotBecome = function (promise, value) {
-        return assert.eventually.notDeepEqual(promise, value);
-    };
+        ///////
+        // Now use the `Assertion` framework to build an `assert` interface.
+        var originalAssertMethods = Object.getOwnPropertyNames(assert).filter(function (propName) {
+            return typeof assert[propName] === "function";
+        });
 
-    assert.eventually = {};
-    originalAssertMethods.forEach(function (assertMethodName) {
-        assert.eventually[assertMethodName] = function (promise) {
-            var otherArgs = Array.prototype.slice.call(arguments, 1);
+        assert.isFulfilled = function (promise, message) {
+            return (new Assertion(promise, message)).to.be.fulfilled;
+        };
 
-            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.isRejected = function (promise, toTestAgainst, message) {
+            if (typeof toTestAgainst === "string") {
+                message = toTestAgainst;
+                toTestAgainst = undefined;
             }
 
-            var returnedPromise = promise.then(
-                function (fulfillmentValue) {
-                    return assert[assertMethodName].apply(assert, [fulfillmentValue].concat(otherArgs));
-                },
-                customRejectionHandler
-            );
+            var assertion = (new Assertion(promise, message));
+            return toTestAgainst !== undefined ? assertion.to.be.rejectedWith(toTestAgainst) : assertion.to.be.rejected;
+        };
 
-            returnedPromise.notify = function (done) {
-                doNotify(returnedPromise, done);
-            };
+        assert.becomes = function (promise, value, message) {
+            return assert.eventually.deepEqual(promise, value, message);
+        };
 
-            return returnedPromise;
+        assert.doesNotBecome = function (promise, value, message) {
+            return assert.eventually.notDeepEqual(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));
+                    };
+                }
+
+                var returnedPromise = promise.then(
+                    function (fulfillmentValue) {
+                        return assert[assertMethodName].apply(assert, [fulfillmentValue].concat(otherArgs));
+                    },
+                    customRejectionHandler
+                );
+
+                returnedPromise.notify = function (done) {
+                    doNotify(returnedPromise, done);
+                };
+
+                return returnedPromise;
+            };
+        });
+    }
+}());

package/package.json

@@ -8,35 +8,34 @@
         "promises",
         "promises-aplus"
     ],
-    "version": "4.0.0",
-    "author": "Domenic Denicola <domenic@domenicdenicola.com> (http://domenicdenicola.com)",
+    "version": "4.3.0",
+    "author": "Domenic Denicola <d@domenic.me> (https://domenic.me)",
     "license": "WTFPL",
-    "repository": {
-        "type": "git",
-        "url": "git://github.com/domenic/chai-as-promised.git"
-    },
-    "bugs": "https://github.com/domenic/chai-as-promised/issues",
+    "repository": "domenic/chai-as-promised",
     "main": "./lib/chai-as-promised.js",
+    "files": [
+        "lib"
+    ],
     "scripts": {
         "test": "mocha",
         "test-browser-q": "coffee ./test/browser/runner.coffee q",
         "test-browser-when": "coffee ./test/browser/runner.coffee when",
         "lint": "jshint ./lib",
-        "cover": "cover run node_modules/mocha/bin/_mocha && cover report html && opener ./cover_html/index.html"
+        "cover": "istanbul cover node_modules/mocha/bin/_mocha && opener ./coverage/lcov-report/lib/chai-as-promised.js.html"
     },
     "peerDependencies": {
-        "chai": ">= 1.7.0 < 2"
+        "chai": ">= 1.7.0 < 3"
     },
     "devDependencies": {
-        "chai": "~1.8.0",
-        "coffee-script": "~1.6.3",
-        "cover": "~0.2.8",
-        "ecstatic": "~0.4.9",
-        "glob": "~3.2.6",
-        "jshint": "~2.1.11",
-        "mocha": "~1.13.0",
-        "opener": "~1.3",
-        "q": "~0.9.7",
-        "underscore": "~1.5.2"
+        "chai": "^2.0.0",
+        "coffee-script": "1.9.0",
+        "istanbul": "0.3.5",
+        "ecstatic": "0.5.8",
+        "glob": "^4.3.5",
+        "jshint": "^2.6.0",
+        "mocha": "^1.21.5",
+        "opener": "^1.4.0",
+        "q": "^1.1.2",
+        "underscore": "1.7.0"
     }
 }