@vitest/expect 2.0.0-beta.3 → 2.0.0-beta.4

package/dist/index.d.ts

@@ -151,6 +151,11 @@ interface Assertion<T = any> extends VitestAssertion<Chai.Assertion, T>, JestAss
     toBeTypeOf: (expected: 'bigint' | 'boolean' | 'function' | 'number' | 'object' | 'string' | 'symbol' | 'undefined') => void;
     toHaveBeenCalledOnce: () => void;
     toSatisfy: <E>(matcher: (value: E) => boolean, message?: string) => void;
+    toHaveResolved: () => void;
+    toHaveResolvedWith: <E>(value: E) => void;
+    toHaveResolvedTimes: (times: number) => void;
+    toHaveLastResolvedWith: <E>(value: E) => void;
+    toHaveNthResolvedWith: <E>(nthCall: number, value: E) => void;
     resolves: PromisifyAssertion<T>;
     rejects: PromisifyAssertion<T>;
 }

package/dist/index.js

@@ -1204,7 +1204,7 @@ const JestChaiExpect = (chai, utils) => {
       return `${i}rd`;
     return `${i}th`;
   };
-  const formatCalls = (spy, msg, actualCall) => {
+  const formatCalls = (spy, msg, showActualCall) => {
     if (spy.mock.calls) {
       msg += c().gray(`
 
@@ -1214,8 +1214,8 @@ ${spy.mock.calls.map((callArg, i) => {
         let methodCall = c().bold(`  ${ordinalOf(i + 1)} ${spy.getMockName()} call:
 
 `);
-        if (actualCall)
-          methodCall += diff(actualCall, callArg, { omitAnnotationLines: true });
+        if (showActualCall)
+          methodCall += diff(showActualCall, callArg, { omitAnnotationLines: true });
         else
           methodCall += stringify(callArg).split("\n").map((line) => `    ${line}`).join("\n");
         methodCall += "\n";
@@ -1228,17 +1228,17 @@ Number of calls: ${c().bold(spy.mock.calls.length)}
 `);
     return msg;
   };
-  const formatReturns = (spy, msg, actualReturn) => {
+  const formatReturns = (spy, results, msg, showActualReturn) => {
     msg += c().gray(`
 
 Received: 
 
-${spy.mock.results.map((callReturn, i) => {
+${results.map((callReturn, i) => {
       let methodCall = c().bold(`  ${ordinalOf(i + 1)} ${spy.getMockName()} call return:
 
 `);
-      if (actualReturn)
-        methodCall += diff(actualReturn, callReturn.value, { omitAnnotationLines: true });
+      if (showActualReturn)
+        methodCall += diff(showActualReturn, callReturn.value, { omitAnnotationLines: true });
       else
         methodCall += stringify(callReturn).split("\n").map((line) => `    ${line}`).join("\n");
       methodCall += "\n";
@@ -1407,78 +1407,154 @@ Number of calls: ${c().bold(spy.mock.calls.length)}
     }
     throw new Error(`"toThrow" expects string, RegExp, function, Error instance or asymmetric matcher, got "${typeof expected}"`);
   });
-  def(["toHaveReturned", "toReturn"], function() {
-    const spy = getSpy(this);
-    const spyName = spy.getMockName();
-    const calledAndNotThrew = spy.mock.calls.length > 0 && spy.mock.results.some(({ type }) => type !== "throw");
-    this.assert(
-      calledAndNotThrew,
-      `expected "${spyName}" to be successfully called at least once`,
-      `expected "${spyName}" to not be successfully called`,
-      calledAndNotThrew,
-      !calledAndNotThrew,
-      false
-    );
-  });
-  def(["toHaveReturnedTimes", "toReturnTimes"], function(times) {
-    const spy = getSpy(this);
-    const spyName = spy.getMockName();
-    const successfulReturns = spy.mock.results.reduce((success, { type }) => type === "throw" ? success : ++success, 0);
-    this.assert(
-      successfulReturns === times,
-      `expected "${spyName}" to be successfully called ${times} times`,
-      `expected "${spyName}" to not be successfully called ${times} times`,
-      `expected number of returns: ${times}`,
-      `received number of returns: ${successfulReturns}`,
-      false
-    );
+  [
+    {
+      name: "toHaveResolved",
+      condition: (spy) => spy.mock.settledResults.length > 0 && spy.mock.settledResults.some(({ type }) => type === "fulfilled"),
+      action: "resolved"
+    },
+    {
+      name: ["toHaveReturned", "toReturn"],
+      condition: (spy) => spy.mock.calls.length > 0 && spy.mock.results.some(({ type }) => type !== "throw"),
+      action: "called"
+    }
+  ].forEach(({ name, condition, action }) => {
+    def(name, function() {
+      const spy = getSpy(this);
+      const spyName = spy.getMockName();
+      const pass = condition(spy);
+      this.assert(
+        pass,
+        `expected "${spyName}" to be successfully ${action} at least once`,
+        `expected "${spyName}" to not be successfully ${action}`,
+        pass,
+        !pass,
+        false
+      );
+    });
   });
-  def(["toHaveReturnedWith", "toReturnWith"], function(value) {
-    const spy = getSpy(this);
-    const spyName = spy.getMockName();
-    const pass = spy.mock.results.some(({ type, value: result }) => type === "return" && equals(value, result));
-    const isNot = utils.flag(this, "negate");
-    const msg = utils.getMessage(
-      this,
-      [
+  [
+    {
+      name: "toHaveResolvedTimes",
+      condition: (spy, times) => spy.mock.settledResults.reduce((s, { type }) => type === "fulfilled" ? ++s : s, 0) === times,
+      action: "resolved"
+    },
+    {
+      name: ["toHaveReturnedTimes", "toReturnTimes"],
+      condition: (spy, times) => spy.mock.results.reduce((s, { type }) => type === "throw" ? s : ++s, 0) === times,
+      action: "called"
+    }
+  ].forEach(({ name, condition, action }) => {
+    def(name, function(times) {
+      const spy = getSpy(this);
+      const spyName = spy.getMockName();
+      const pass = condition(spy, times);
+      this.assert(
         pass,
-        `expected "${spyName}" to return with: #{exp} at least once`,
-        `expected "${spyName}" to not return with: #{exp}`,
-        value
-      ]
-    );
-    if (pass && isNot || !pass && !isNot)
-      throw new AssertionError(formatReturns(spy, msg, value));
+        `expected "${spyName}" to be successfully ${action} ${times} times`,
+        `expected "${spyName}" to not be successfully ${action} ${times} times`,
+        `expected resolved times: ${times}`,
+        `received resolved times: ${pass}`,
+        false
+      );
+    });
   });
-  def(["toHaveLastReturnedWith", "lastReturnedWith"], function(value) {
-    const spy = getSpy(this);
-    const spyName = spy.getMockName();
-    const { value: lastResult } = spy.mock.results[spy.mock.results.length - 1];
-    const pass = equals(lastResult, value);
-    this.assert(
-      pass,
-      `expected last "${spyName}" call to return #{exp}`,
-      `expected last "${spyName}" call to not return #{exp}`,
-      value,
-      lastResult
-    );
+  [
+    {
+      name: "toHaveResolvedWith",
+      condition: (spy, value) => spy.mock.settledResults.some(({ type, value: result }) => type === "fulfilled" && equals(value, result)),
+      action: "resolve"
+    },
+    {
+      name: ["toHaveReturnedWith", "toReturnWith"],
+      condition: (spy, value) => spy.mock.results.some(({ type, value: result }) => type === "return" && equals(value, result)),
+      action: "return"
+    }
+  ].forEach(({ name, condition, action }) => {
+    def(name, function(value) {
+      const spy = getSpy(this);
+      const pass = condition(spy, value);
+      const isNot = utils.flag(this, "negate");
+      if (pass && isNot || !pass && !isNot) {
+        const spyName = spy.getMockName();
+        const msg = utils.getMessage(
+          this,
+          [
+            pass,
+            `expected "${spyName}" to ${action} with: #{exp} at least once`,
+            `expected "${spyName}" to not ${action} with: #{exp}`,
+            value
+          ]
+        );
+        const results = action === "return" ? spy.mock.results : spy.mock.settledResults;
+        throw new AssertionError(formatReturns(spy, results, msg, value));
+      }
+    });
   });
-  def(["toHaveNthReturnedWith", "nthReturnedWith"], function(nthCall, value) {
-    const spy = getSpy(this);
-    const spyName = spy.getMockName();
-    const isNot = utils.flag(this, "negate");
-    const { type: callType, value: callResult } = spy.mock.results[nthCall - 1];
-    const ordinalCall = `${ordinalOf(nthCall)} call`;
-    if (!isNot && callType === "throw")
-      chai.assert.fail(`expected ${ordinalCall} to return #{exp}, but instead it threw an error`);
-    const nthCallReturn = equals(callResult, value);
-    this.assert(
-      nthCallReturn,
-      `expected ${ordinalCall} "${spyName}" call to return #{exp}`,
-      `expected ${ordinalCall} "${spyName}" call to not return #{exp}`,
-      value,
-      callResult
-    );
+  [
+    {
+      name: "toHaveLastResolvedWith",
+      condition: (spy, value) => {
+        const result = spy.mock.settledResults[spy.mock.settledResults.length - 1];
+        return result && result.type === "fulfilled" && equals(result.value, value);
+      },
+      action: "resolve"
+    },
+    {
+      name: ["toHaveLastReturnedWith", "lastReturnedWith"],
+      condition: (spy, value) => {
+        const result = spy.mock.results[spy.mock.results.length - 1];
+        return result && result.type === "return" && equals(result.value, value);
+      },
+      action: "return"
+    }
+  ].forEach(({ name, condition, action }) => {
+    def(name, function(value) {
+      const spy = getSpy(this);
+      const results = action === "return" ? spy.mock.results : spy.mock.settledResults;
+      const result = results[results.length - 1];
+      const spyName = spy.getMockName();
+      this.assert(
+        condition(spy, value),
+        `expected last "${spyName}" call to ${action} #{exp}`,
+        `expected last "${spyName}" call to not ${action} #{exp}`,
+        value,
+        result == null ? void 0 : result.value
+      );
+    });
+  });
+  [
+    {
+      name: "toHaveNthResolvedWith",
+      condition: (spy, index, value) => {
+        const result = spy.mock.settledResults[index - 1];
+        return result && result.type === "fulfilled" && equals(result.value, value);
+      },
+      action: "resolve"
+    },
+    {
+      name: ["toHaveNthReturnedWith", "nthReturnedWith"],
+      condition: (spy, index, value) => {
+        const result = spy.mock.results[index - 1];
+        return result && result.type === "return" && equals(result.value, value);
+      },
+      action: "return"
+    }
+  ].forEach(({ name, condition, action }) => {
+    def(name, function(nthCall, value) {
+      const spy = getSpy(this);
+      const spyName = spy.getMockName();
+      const results = action === "return" ? spy.mock.results : spy.mock.settledResults;
+      const result = results[nthCall - 1];
+      const ordinalCall = `${ordinalOf(nthCall)} call`;
+      this.assert(
+        condition(spy, nthCall, value),
+        `expected ${ordinalCall} "${spyName}" call to ${action} #{exp}`,
+        `expected ${ordinalCall} "${spyName}" call to not ${action} #{exp}`,
+        value,
+        result == null ? void 0 : result.value
+      );
+    });
   });
   def("toSatisfy", function(matcher, message) {
     return this.be.satisfy(matcher, message);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/expect",
   "type": "module",
-  "version": "2.0.0-beta.3",
+  "version": "2.0.0-beta.4",
   "description": "Jest's expect matchers as a Chai plugin",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -31,14 +31,14 @@
   ],
   "dependencies": {
     "chai": "^5.1.1",
-    "@vitest/spy": "2.0.0-beta.3",
-    "@vitest/utils": "2.0.0-beta.3"
+    "@vitest/spy": "2.0.0-beta.4",
+    "@vitest/utils": "2.0.0-beta.4"
   },
   "devDependencies": {
     "@types/chai": "4.3.6",
     "picocolors": "^1.0.0",
     "rollup-plugin-copy": "^3.5.0",
-    "@vitest/runner": "2.0.0-beta.3"
+    "@vitest/runner": "2.0.0-beta.4"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",