chai-as-promised 5.0.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

@@ -27,19 +27,19 @@ you can write code that expresses what you really mean:
 return doSomethingAsync().should.eventually.equal("foo");
 ```
 
-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:
+or if you have a case where `return` is not preferable (e.g. style considerations) or not possible (e.g. the testing framework doesn't allow returning promises to signal asynchronous test completion), then you can use the following workaround (where `done()` is supplied by the test framework):
 
 ```javascript
 doSomethingAsync().should.eventually.equal("foo").notify(done);
 ```
 
+*Notice*: either `return` or `notify(done)` _must_ be used with promise assertions. This can be a slight departure from the existing format of assertions being used on a project or by a team. Those other assertions are likely synchronous and thus do not require special handling.
+
 ## How to Use
 
 ### `should`/`expect` Interface
 
-The most powerful extension provided by Chai as Promised is the `eventually` property. With it, you can transform any
-existing Chai assertion into one that acts on a promise:
+The most powerful extension provided by Chai as Promised is the `eventually` property. With it, you can transform any existing Chai assertion into one that acts on a promise:
 
 ```javascript
 (2 + 2).should.equal(4);
@@ -66,8 +66,7 @@ return promise.should.be.rejectedWith(Error); // other variants of Chai's `throw
 
 ### `assert` Interface
 
-As with the `should`/`expect` interface, Chai as Promised provides an `eventually` extender to `chai.assert`, allowing
-any existing Chai assertion to be used on a promise:
+As with the `should`/`expect` interface, Chai as Promised provides an `eventually` extender to `chai.assert`, allowing any existing Chai assertion to be used on a promise:
 
 ```javascript
 assert.equal(2 + 2, 4, "This had better be true");
@@ -91,9 +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][sinon], perhaps in conjunction with [Sinon–Chai][sinon-chai]:
 
 ```javascript
 var progressSpy = sinon.spy();
@@ -107,10 +104,7 @@ 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:
+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) {
@@ -122,8 +116,7 @@ chaiAsPromised.transferPromiseness = function (assertion, 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:
+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) {
@@ -131,12 +124,10 @@ 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:
+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.
@@ -153,17 +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
-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.
+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
 
-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][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) {
@@ -175,12 +164,9 @@ it("should be rejected", function (done) {
 });
 ```
 
-In these examples, if the conditions are not met, the test runner will receive an error of the form `"expected promise
-to be fulfilled but it was rejected with [Error: error message]"`, or `"expected promise to be rejected but it was
-fulfilled."`
+In these examples, if the conditions are not met, the test runner will receive an error of the form `"expected promise to be fulfilled but it was rejected with [Error: error message]"`, or `"expected promise to be rejected but it was fulfilled."`
 
-There's another form of `notify` which is useful in certain situations, like doing assertions after a promise is
-complete. For example:
+There's another form of `notify` which is useful in certain situations, like doing assertions after a promise is complete. For example:
 
 ```javascript
 it("should change the state", function (done) {
@@ -191,26 +177,23 @@ it("should change the state", function (done) {
 });
 ```
 
-Notice how `.notify(done)` is hanging directly off of `.should`, instead of appearing after a promise assertion. This
-indicates to Chai as Promised that it should pass fulfillment or rejection directly through to the testing framework.
-Thus, the above code will fail with a Chai as Promised error (`"expected promise to be fulfilled…"`) if `promise` is
-rejected, but will fail with a simple Chai error (`expected "before" to equal "after"`) if `otherState` does not change.
+Notice how `.notify(done)` is hanging directly off of `.should`, instead of appearing after a promise assertion. This indicates to Chai as Promised that it should pass fulfillment or rejection directly through to the testing framework. Thus, the above code will fail with a Chai as Promised error (`"expected promise to be fulfilled…"`) if `promise` is rejected, but will fail with a simple Chai error (`expected "before" to equal "after"`) if `otherState` does not change.
 
-Another example of where this can be useful is when performing assertions on multiple promises:
+### Multiple Promise Assertions
+
+To perform assertions on multiple promises, use `Promise.all` to combine multiple Chai as Promised assertions:
 
 ```javascript
-it("should all be well", function (done) {
-    Q.all([
+it("should all be well", function () {
+    return Promise.all([
         promiseA.should.become("happy"),
         promiseB.should.eventually.have.property("fun times"),
         promiseC.should.be.rejectedWith(TypeError, "only joyful types are allowed")
-    ]).should.notify(done);
+    ]);
 });
 ```
 
-This will pass any failures of the individual promise assertions up to the test framework, instead of wrapping them in
-an `"expected promise to be fulfilled…"` message as would happen if you did
-`Q.all([…]).should.be.fulfilled.and.notify(done)`.
+This will pass any failures of the individual promise assertions up to the test framework, instead of wrapping them in an `"expected promise to be fulfilled…"` message as would happen if you did `return Promise.all([…]).should.be.fulfilled`. If you can't use `return`, then use `.should.notify(done)`, similar to the previous examples.
 
 ## Installation and Setup
 
@@ -223,35 +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
 
@@ -275,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,371 +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 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";
-        }
+    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 (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/).");
-            }
-        }
+    // 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) {
-            return this.eventually.deep.equal(value);
-        });
+    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

@@ -1,43 +1,47 @@
 {
-    "name": "chai-as-promised",
-    "description": "Extends Chai with assertions about promises.",
-    "keywords": [
-        "chai",
-        "testing",
-        "assertions",
-        "promises",
-        "promises-aplus"
-    ],
-    "version": "5.0.0",
-    "author": "Domenic Denicola <d@domenic.me> (https://domenic.me)",
-    "license": "WTFPL",
-    "repository": "domenic/chai-as-promised",
-    "main": "./lib/chai-as-promised.js",
-    "files": [
-        "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-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"
-    },
-    "peerDependencies": {
-        "chai": ">= 2.1.2 < 3"
-    },
-    "devDependencies": {
-        "chai": "^2.1.2",
-        "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"
-    }
+  "name": "chai-as-promised",
+  "description": "Extends Chai with assertions about promises.",
+  "keywords": [
+    "chai",
+    "chai-plugin",
+    "browser",
+    "async",
+    "testing",
+    "assertions",
+    "promises",
+    "promises-aplus"
+  ],
+  "version": "6.0.0",
+  "author": "Domenic Denicola <d@domenic.me> (https://domenic.me)",
+  "license": "WTFPL",
+  "repository": "domenic/chai-as-promised",
+  "main": "./lib/chai-as-promised.js",
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "test": "npm run test-plugin && npm run test-intercompatibility",
+    "test-plugin": "mocha",
+    "test-intercompatibility": "mocha test-intercompatibility --opts test-intercompatibility/mocha.opts",
+    "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",
+    "ecstatic": "^1.3.1",
+    "glob": "^6.0.1",
+    "istanbul": "0.4.1",
+    "jshint": "^2.8.0",
+    "mocha": "^2.3.4",
+    "opener": "^1.4.1",
+    "q": "^1.4.1",
+    "underscore": "1.8.3"
+  }
 }