chai-as-promised 7.1.1 → 8.0.0-beta.1

package/README.md

@@ -83,9 +83,9 @@ return assert.isFulfilled(promise, "optional message");
 return assert.becomes(promise, "foo", "optional message");
 return assert.doesNotBecome(promise, "foo", "optional message");
 
-return assert.isRejected(promise, "optional message");
 return assert.isRejected(promise, Error, "optional message");
-return assert.isRejected(promise, /error message matcher/, "optional message");
+return assert.isRejected(promise, /error message regex matcher/, "optional message");
+return assert.isRejected(promise, "substring to search error message for", "optional message");
 ```
 
 ### Progress Callbacks
@@ -107,11 +107,13 @@ return promise.then(null, null, progressSpy).then(function () {
 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) {
+import {setTransferPromiseness} from 'chai-as-promised';
+
+setTransferPromiseness(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
@@ -119,9 +121,11 @@ chaiAsPromised.transferPromiseness = function (assertion, promise) {
 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) {
+import {transformAsserterArgs} from 'chai-as-promised';
+
+setTransformAsserterArgs(function (args) {
     return args.map(function (x) { return x + 1; });
-}
+});
 
 Promise.resolve(2).should.eventually.equal(2); // will now fail!
 Promise.resolve(3).should.eventually.equal(2); // will now pass!
@@ -133,9 +137,9 @@ The transform can even be asynchronous, returning a promise for an array instead
 // 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) {
+setTransformAsserterArgs(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
@@ -179,6 +183,17 @@ 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.
 
+### Working with `async`/`await` and Promise-Friendly Test Runners
+
+Since any assertion that must wait on a promise returns a promise itself, if you're able to use `async`/`await` and your test runner supports returning a promise from test methods, you can await assertions in tests.  In many cases you can avoid using Chai as Promised at all by performing a synchronous assertion after an `await`, but awaiting `rejectedWith` is often more convenient than using `try`/`catch` blocks without Chai as Promised:
+
+```javascript
+it('should work well with async/await', async () => {
+  (await Promise.resolve(42)).should.equal(42)
+  await Promise.reject(new Error()).should.be.rejectedWith(Error);
+});
+```
+
 ### Multiple Promise Assertions
 
 To perform assertions on multiple promises, use `Promise.all` to combine multiple Chai as Promised assertions:
@@ -202,15 +217,15 @@ This will pass any failures of the individual promise assertions up to the test
 Do an `npm install chai-as-promised` to get up and running. Then:
 
 ```javascript
-var chai = require("chai");
-var chaiAsPromised = require("chai-as-promised");
+import * as chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
 
 chai.use(chaiAsPromised);
 
 // Then either:
-var expect = chai.expect;
+const expect = chai.expect;
 // or:
-var assert = chai.assert;
+const assert = chai.assert;
 // or:
 chai.should();
 // according to your preference of assertion style
@@ -220,14 +235,12 @@ You can of course put this code in a common test fixture file; for an example us
 
 **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.
 
-### In the Browser
-
-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.
-
 ### Karma
 
 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.
 
 ### Browser/Node Compatibility
 
-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/).
+Chai as Promised requires support for ES modules and modern JavaScript syntax.
+If your browser doesn't support this, you will need to transpile it down using
+a tool like [Babel](https://babeljs.io/).

package/lib/chai-as-promised.js

@@ -1,361 +1,453 @@
-"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;
+import * as checkErrorDefault from 'check-error';
+
+let checkError = checkErrorDefault;
+
+export default function (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;
+  }
+
+  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 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.");
-        }
-        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 proxifyIfSupported(assertion) {
-        return proxify === undefined ? assertion : proxify(assertion);
-    }
-
-    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 proxifyIfSupported(asserter.apply(this, arguments));
-        });
-    }
+  function proxifyIfSupported(assertion) {
+    return proxify === undefined ? assertion : proxify(assertion);
+  }
 
-    function doNotify(promise, done) {
-        promise.then(() => done(), done);
-    }
+  function method(name, asserter) {
+    utils.addMethod(Assertion.prototype, name, function () {
+      assertIsAboutPromise(this);
+      return 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 property(name, asserter) {
+    utils.addProperty(Assertion.prototype, name, function () {
+      assertIsAboutPromise(this);
+      return proxifyIfSupported(asserter.apply(this, arguments));
+    });
+  }
+
+  function doNotify(promise, done) {
+    promise.then(() => 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);
+  }
+
+  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 getReasonName(reason) {
+    return reason instanceof Error
+      ? reason.toString()
+      : checkError.getConstructorName(reason);
+  }
+
+  // Grab these first, before we modify `Assertion.prototype`.
+
+  const propertyNames = Object.getOwnPropertyNames(Assertion.prototype);
+
+  const propertyDescs = {};
+  for (const name of propertyNames) {
+    propertyDescs[name] = Object.getOwnPropertyDescriptor(
+      Assertion.prototype,
+      name
+    );
+  }
+
+  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;
+      }
+    );
+
+    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)}
+        );
 
-    function assertIfNotNegated(assertion, message, extra) {
-        assertion.assert(false, message, null, extra.expected, extra.actual);
+        // Return the reason, transforming this into a fulfillment, to allow further assertions, e.g.
+        // `promise.should.be.rejected.and.eventually.equal("reason")`.
+        return reason;
+      }
+    );
+
+    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 */
     }
 
-    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 (message !== undefined) {
+      utils.flag(this, 'message', message);
     }
 
-    function getReasonName(reason) {
-        return reason instanceof Error ? reason.toString() : checkError.getConstructorName(reason);
+    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);
 
-    // Grab these first, before we modify `Assertion.prototype`.
-
-    const propertyNames = Object.getOwnPropertyNames(Assertion.prototype);
-
-    const propertyDescs = {};
-    for (const name of propertyNames) {
-        propertyDescs[name] = Object.getOwnPropertyDescriptor(Assertion.prototype, name);
+    let matcherRelation = 'including';
+    if (errMsgMatcher instanceof RegExp) {
+      matcherRelation = 'matching';
     }
 
-    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 */
+    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;
         }
 
-        if (message !== undefined) {
-            utils.flag(this, "message", message);
-        }
-
-        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);
+        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 === reason ||
+          (errMsgMatcher &&
+            reason &&
+            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
+            );
+          }
         } else {
-            errorLike = null;
+          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 (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)
+            );
+          }
         }
-        const everyArgIsDefined = Boolean(errorLike && errMsgMatcher);
 
-        let matcherRelation = "including";
-        if (errMsgMatcher instanceof RegExp) {
-            matcherRelation = "matching";
+        return reason;
+      }
+    );
+
+    transferPromiseness(this, derivedPromise);
+    return this;
+  });
+
+  property('eventually', function () {
+    utils.flag(this, 'eventually', true);
+    return this;
+  });
+
+  method('notify', function (done) {
+    doNotify(getBasePromise(this), done);
+    return this;
+  });
+
+  method('become', function (value, message) {
+    return this.eventually.deep.equal(value, message);
+  });
+
+  // ### `eventually`
+
+  // 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';
+  });
+
+  methodNames.forEach((methodName) => {
+    Assertion.overwriteMethod(
+      methodName,
+      (originalMethod) =>
+        function () {
+          return doAsserterAsyncAndAddThen(originalMethod, this, arguments);
         }
-
-        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(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);
-                    }
-                } 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 (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));
-                    }
-                }
-
-                return reason;
-            }
-        );
-
-        module.exports.transferPromiseness(this, derivedPromise);
-        return this;
-    });
-
-    property("eventually", function () {
-        utils.flag(this, "eventually", true);
-        return this;
-    });
-
-    method("notify", function (done) {
-        doNotify(getBasePromise(this), done);
-        return this;
-    });
-
-    method("become", function (value, message) {
-        return this.eventually.deep.equal(value, message);
-    });
-
-    // ### `eventually`
-
-    // 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";
-    });
-
-    methodNames.forEach(methodName => {
-        Assertion.overwriteMethod(methodName, originalMethod => function () {
+    );
+  });
+
+  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 = Object.prototype.hasOwnProperty.call(
+      Assertion.prototype.__methods,
+      getterName
+    );
+
+    if (isChainableMethod) {
+      Assertion.overwriteChainableMethod(
+        getterName,
+        (originalMethod) =>
+          function () {
             return doAsserterAsyncAndAddThen(originalMethod, this, arguments);
-        });
-    });
-
-    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);
-                }
+          },
+        (originalGetter) =>
+          function () {
+            return doAsserterAsyncAndAddThen(originalGetter, this);
+          }
+      );
+    } else {
+      Assertion.overwriteProperty(
+        getterName,
+        (originalGetter) =>
+          function () {
+            return proxifyIfSupported(
+              doAsserterAsyncAndAddThen(originalGetter, this)
             );
-        } else {
-            Assertion.overwriteProperty(getterName, originalGetter => function () {
-                return proxifyIfSupported(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")) {
-            asserter.apply(assertion, args);
-            return assertion;
-        }
-
-        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;
-        });
-
-        module.exports.transferPromiseness(assertion, derivedPromise);
-        return assertion;
+          }
+      );
+    }
+  });
+
+  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.
-    const originalAssertMethods = Object.getOwnPropertyNames(assert).filter(propName => {
-        return typeof assert[propName] === "function";
-    });
-
-    assert.isFulfilled = (promise, message) => (new Assertion(promise, message)).to.be.fulfilled;
-
-    assert.isRejected = (promise, errorLike, errMsgMatcher, message) => {
-        const assertion = new Assertion(promise, message);
-        return assertion.to.be.rejectedWith(errorLike, errMsgMatcher, message);
-    };
-
-    assert.becomes = (promise, value, message) => assert.eventually.deepEqual(promise, value, message);
-
-    assert.doesNotBecome = (promise, value, message) => assert.eventually.notDeepEqual(promise, value, message);
-
-    assert.eventually = {};
-    originalAssertMethods.forEach(assertMethodName => {
-        assert.eventually[assertMethodName] = function (promise) {
-            const otherArgs = Array.prototype.slice.call(arguments, 1);
-
-            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)}`);
-                };
-            }
-
-            const returnedPromise = promise.then(
-                fulfillmentValue => assert[assertMethodName].apply(assert, [fulfillmentValue].concat(otherArgs)),
-                customRejectionHandler
-            );
-
-            returnedPromise.notify = done => {
-                doNotify(returnedPromise, done);
-            };
-
-            return returnedPromise;
+    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 ? 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;
+      });
+
+    transferPromiseness(assertion, derivedPromise);
+    return assertion;
+  }
+
+  // ### Now use the `Assertion` framework to build an `assert` interface.
+  const originalAssertMethods = Object.getOwnPropertyNames(assert).filter(
+    (propName) => {
+      return typeof assert[propName] === 'function';
+    }
+  );
+
+  assert.isFulfilled = (promise, message) =>
+    new Assertion(promise, message).to.be.fulfilled;
+
+  assert.isRejected = (promise, errorLike, errMsgMatcher, message) => {
+    const assertion = new Assertion(promise, message);
+    return assertion.to.be.rejectedWith(errorLike, errMsgMatcher, message);
+  };
+
+  assert.becomes = (promise, value, message) =>
+    assert.eventually.deepEqual(promise, value, message);
+
+  assert.doesNotBecome = (promise, value, message) =>
+    assert.eventually.notDeepEqual(promise, value, message);
+
+  assert.eventually = {};
+  originalAssertMethods.forEach((assertMethodName) => {
+    assert.eventually[assertMethodName] = function (promise) {
+      const otherArgs = Array.prototype.slice.call(arguments, 1);
+
+      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)}`
+          );
         };
-    });
-};
-
-module.exports.transferPromiseness = (assertion, promise) => {
-    assertion.then = promise.then.bind(promise);
-};
-
-module.exports.transformAsserterArgs = values => values;
+      }
+
+      const returnedPromise = promise.then(
+        (fulfillmentValue) =>
+          assert[assertMethodName].apply(
+            assert,
+            [fulfillmentValue].concat(otherArgs)
+          ),
+        customRejectionHandler
+      );
+
+      returnedPromise.notify = (done) => {
+        doNotify(returnedPromise, done);
+      };
+
+      return returnedPromise;
+    };
+  });
+}
+
+function defaultTransferPromiseness(assertion, promise) {
+  assertion.then = promise.then.bind(promise);
+}
+
+function defaultTransformAsserterArgs(values) {
+  return values;
+}
+
+let customTransferPromiseness;
+let customTransformAsserterArgs;
+
+export function setTransferPromiseness(fn) {
+  customTransferPromiseness = fn || defaultTransferPromiseness;
+}
+
+export function setTransformAsserterArgs(fn) {
+  customTransformAsserterArgs = fn || defaultTransformAsserterArgs;
+}
+
+export function transferPromiseness(assertion, promise) {
+  if (customTransferPromiseness) {
+    customTransferPromiseness(assertion, promise);
+  } else {
+    defaultTransferPromiseness(assertion, promise);
+  }
+}
+
+export function transformAsserterArgs(values) {
+  if (customTransformAsserterArgs) {
+    return customTransformAsserterArgs(values);
+  }
+  return defaultTransformAsserterArgs(values);
+}

package/package.json

@@ -1,5 +1,6 @@
 {
   "name": "chai-as-promised",
+  "type": "module",
   "description": "Extends Chai with assertions about promises.",
   "keywords": [
     "chai",
@@ -11,30 +12,36 @@
     "promises",
     "promises-aplus"
   ],
-  "version": "7.1.1",
+  "version": "8.0.0-beta.1",
   "author": "Domenic Denicola <d@domenic.me> (https://domenic.me)",
   "license": "WTFPL",
-  "repository": "domenic/chai-as-promised",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chaijs/chai-as-promised.git"
+  },
   "main": "./lib/chai-as-promised.js",
+  "exports": {
+    ".": "./lib/chai-as-promised.js"
+  },
   "files": [
     "lib"
   ],
   "scripts": {
-    "test": "mocha",
-    "test-travis": "npm install chai@$CHAI_VERSION && npm test",
+    "test": "c8 mocha",
     "lint": "eslint .",
-    "cover": "istanbul cover node_modules/mocha/bin/_mocha && opener ./coverage/lcov-report/lib/chai-as-promised.js.html"
+    "format": "prettier --write lib test"
   },
   "dependencies": {
-    "check-error": "^1.0.2"
+    "check-error": "^2.0.0"
   },
   "peerDependencies": {
-    "chai": ">= 2.1.2 < 5"
+    "chai": ">= 2.1.2 < 6"
   },
   "devDependencies": {
-    "chai": "^4.0.2",
-    "eslint": "^3.19.0",
-    "istanbul": "0.4.5",
-    "mocha": "^3.4.2"
+    "c8": "^9.1.0",
+    "chai": "^5.1.0",
+    "eslint": "^8.57.0",
+    "mocha": "^10.4.0",
+    "prettier": "^3.2.5"
   }
 }