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

package/dist/index.d.ts

@@ -65,6 +65,7 @@ interface MatcherState {
         subsetEquality: Tester;
     };
     soft?: boolean;
+    poll?: boolean;
 }
 interface SyncExpectationResult {
     pass: boolean;
@@ -80,12 +81,7 @@ interface RawMatcherFn<T extends MatcherState = MatcherState> {
 type MatchersObject<T extends MatcherState = MatcherState> = Record<string, RawMatcherFn<T>>;
 interface ExpectStatic extends Chai.ExpectStatic, AsymmetricMatchersContaining {
     <T>(actual: T, message?: string): Assertion<T>;
-    unreachable: (message?: string) => never;
-    soft: <T>(actual: T, message?: string) => Assertion<T>;
     extend: (expects: MatchersObject) => void;
-    addEqualityTesters: (testers: Array<Tester>) => void;
-    assertions: (expected: number) => void;
-    hasAssertions: () => void;
     anything: () => any;
     any: (constructor: unknown) => any;
     getState: () => MatcherState;
@@ -150,12 +146,18 @@ type VitestAssertion<A, T> = {
 type Promisify<O> = {
     [K in keyof O]: O[K] extends (...args: infer A) => infer R ? O extends R ? Promisify<O[K]> : (...args: A) => Promise<R> : O[K];
 };
+type PromisifyAssertion<T> = Promisify<Assertion<T>>;
 interface Assertion<T = any> extends VitestAssertion<Chai.Assertion, T>, JestAssertion<T> {
     toBeTypeOf: (expected: 'bigint' | 'boolean' | 'function' | 'number' | 'object' | 'string' | 'symbol' | 'undefined') => void;
     toHaveBeenCalledOnce: () => void;
     toSatisfy: <E>(matcher: (value: E) => boolean, message?: string) => void;
-    resolves: Promisify<Assertion<T>>;
-    rejects: Promisify<Assertion<T>>;
+    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>;
 }
 declare global {
     namespace jest {
@@ -255,4 +257,4 @@ declare const JestChaiExpect: ChaiPlugin;
 
 declare const JestExtend: ChaiPlugin;
 
-export { ASYMMETRIC_MATCHERS_OBJECT, Any, Anything, ArrayContaining, type Assertion, AsymmetricMatcher, type AsymmetricMatcherInterface, type AsymmetricMatchersContaining, type AsyncExpectationResult, type ChaiPlugin, type ExpectStatic, type ExpectationResult, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, type JestAssertion, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, type MatcherHintOptions, type MatcherState, type MatchersObject, ObjectContaining, type RawMatcherFn, StringContaining, StringMatching, type SyncExpectationResult, type Tester, type TesterContext, addCustomEqualityTesters, arrayBufferEquality, equals, fnNameFor, generateToBeMessage, getObjectKeys, getObjectSubset, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isImmutableUnorderedKeyed, isImmutableUnorderedSet, iterableEquality, pluralize, setState, sparseArrayEquality, subsetEquality, typeEquality };
+export { ASYMMETRIC_MATCHERS_OBJECT, Any, Anything, ArrayContaining, type Assertion, AsymmetricMatcher, type AsymmetricMatcherInterface, type AsymmetricMatchersContaining, type AsyncExpectationResult, type ChaiPlugin, type ExpectStatic, type ExpectationResult, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, type JestAssertion, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, type MatcherHintOptions, type MatcherState, type MatchersObject, ObjectContaining, type PromisifyAssertion, type RawMatcherFn, StringContaining, StringMatching, type SyncExpectationResult, type Tester, type TesterContext, addCustomEqualityTesters, arrayBufferEquality, equals, fnNameFor, generateToBeMessage, getObjectKeys, getObjectSubset, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isImmutableUnorderedKeyed, isImmutableUnorderedSet, iterableEquality, pluralize, setState, sparseArrayEquality, subsetEquality, typeEquality };

package/dist/index.js

@@ -254,7 +254,7 @@ function isDomNode(obj) {
 function fnNameFor(func) {
   if (func.name)
     return func.name;
-  const matches = functionToString.call(func).match(/^(?:async)?\s*function\s*\*?\s*([\w$]+)\s*\(/);
+  const matches = functionToString.call(func).match(/^(?:async)?\s*function\s*(?:\*\s*)?([\w$]+)\s*\(/);
   return matches ? matches[1] : "<anonymous>";
 }
 function getPrototype(obj) {
@@ -661,7 +661,7 @@ class Any extends AsymmetricMatcher {
     if (func.name)
       return func.name;
     const functionToString = Function.prototype.toString;
-    const matches = functionToString.call(func).match(/^(?:async)?\s*function\s*\*?\s*([\w$]+)\s*\(/);
+    const matches = functionToString.call(func).match(/^(?:async)?\s*function\s*(?:\*\s*)?([\w$]+)\s*\(/);
     return matches ? matches[1] : "<anonymous>";
   }
   asymmetricMatch(other) {
@@ -817,10 +817,9 @@ function recordAsyncExpect(test, promise) {
 function wrapSoft(utils, fn) {
   return function(...args) {
     var _a;
-    const test = utils.flag(this, "vitest-test");
-    const state = (test == null ? void 0 : test.context._local) ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);
-    if (!state.soft)
+    if (!utils.flag(this, "soft"))
       return fn.apply(this, args);
+    const test = utils.flag(this, "vitest-test");
     if (!test)
       throw new Error("expect.soft() can only be used inside a test");
     try {
@@ -1205,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(`
 
@@ -1215,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";
@@ -1229,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";
@@ -1408,88 +1407,171 @@ 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);
   });
+  def("withContext", function(context) {
+    for (const key in context)
+      utils.flag(this, key, context[key]);
+    return this;
+  });
   utils.addProperty(chai.Assertion.prototype, "resolves", function __VITEST_RESOLVES__() {
     const error = new Error("resolves");
     utils.flag(this, "promise", "resolves");
     utils.flag(this, "error", error);
     const test = utils.flag(this, "vitest-test");
     const obj = utils.flag(this, "object");
+    if (utils.flag(this, "poll"))
+      throw new SyntaxError(`expect.poll() is not supported in combination with .resolves`);
     if (typeof (obj == null ? void 0 : obj.then) !== "function")
       throw new TypeError(`You must provide a Promise to expect() when using .resolves, not '${typeof obj}'.`);
     const proxy = new Proxy(this, {
@@ -1526,6 +1608,8 @@ Number of calls: ${c().bold(spy.mock.calls.length)}
     const test = utils.flag(this, "vitest-test");
     const obj = utils.flag(this, "object");
     const wrapper = typeof obj === "function" ? obj() : obj;
+    if (utils.flag(this, "poll"))
+      throw new SyntaxError(`expect.poll() is not supported in combination with .rejects`);
     if (typeof (wrapper == null ? void 0 : wrapper.then) !== "function")
       throw new TypeError(`You must provide a Promise to expect() when using .rejects, not '${typeof wrapper}'.`);
     const proxy = new Proxy(this, {
@@ -1575,7 +1659,9 @@ function getMatcherState(assertion, expect) {
     promise,
     equals,
     // needed for built-in jest-snapshots, but we don't use it
-    suppressedErrors: []
+    suppressedErrors: [],
+    soft: util.flag(assertion, "soft"),
+    poll: util.flag(assertion, "poll")
   };
   return {
     state: matcherState,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/expect",
   "type": "module",
-  "version": "2.0.0-beta.2",
+  "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/utils": "2.0.0-beta.2",
-    "@vitest/spy": "2.0.0-beta.2"
+    "@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.2"
+    "@vitest/runner": "2.0.0-beta.4"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",