@vitest/expect 2.1.5 → 2.2.0-beta.2

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { MockInstance } from '@vitest/spy';
 import { stringify, Constructable } from '@vitest/utils';
 import * as tinyrainbow from 'tinyrainbow';
 import { Formatter } from 'tinyrainbow';
@@ -549,6 +550,14 @@ interface Assertion<T = any> extends VitestAssertion<Chai.Assertion, T>, JestAss
      * expect(mockFunc).toHaveBeenCalledOnce();
      */
     toHaveBeenCalledOnce: () => void;
+    /**
+     * Ensure that a mock function is called with specific arguments and called
+     * exactly once.
+     *
+     * @example
+     * expect(mockFunc).toHaveBeenCalledExactlyOnceWith('arg1', 42);
+     */
+    toHaveBeenCalledExactlyOnceWith: <E extends any[]>(...args: E) => void;
     /**
      * Checks that a value satisfies a custom matcher function.
      *
@@ -559,6 +568,36 @@ interface Assertion<T = any> extends VitestAssertion<Chai.Assertion, T>, JestAss
      * expect(age).toSatisfy(val => val >= 18, 'Age must be at least 18');
      */
     toSatisfy: <E>(matcher: (value: E) => boolean, message?: string) => void;
+    /**
+     * This assertion checks if a `Mock` was called before another `Mock`.
+     * @param mock - A mock function created by `vi.spyOn` or `vi.fn`
+     * @param failIfNoFirstInvocation - Fail if the first mock was never called
+     * @example
+     * const mock1 = vi.fn()
+     * const mock2 = vi.fn()
+     *
+     * mock1()
+     * mock2()
+     * mock1()
+     *
+     * expect(mock1).toHaveBeenCalledBefore(mock2)
+     */
+    toHaveBeenCalledBefore: (mock: MockInstance, failIfNoFirstInvocation?: boolean) => void;
+    /**
+     * This assertion checks if a `Mock` was called after another `Mock`.
+     * @param mock - A mock function created by `vi.spyOn` or `vi.fn`
+     * @param failIfNoFirstInvocation - Fail if the first mock was never called
+     * @example
+     * const mock1 = vi.fn()
+     * const mock2 = vi.fn()
+     *
+     * mock2()
+     * mock1()
+     * mock2()
+     *
+     * expect(mock1).toHaveBeenCalledAfter(mock2)
+     */
+    toHaveBeenCalledAfter: (mock: MockInstance, failIfNoFirstInvocation?: boolean) => void;
     /**
      * Checks that a promise resolves successfully at least once.
      *

package/dist/index.js

@@ -1465,6 +1465,25 @@ const JestChaiExpect = (chai, utils) => {
       throw new AssertionError(formatCalls(spy, msg, args));
     }
   });
+  def("toHaveBeenCalledExactlyOnceWith", function(...args) {
+    const spy = getSpy(this);
+    const spyName = spy.getMockName();
+    const callCount = spy.mock.calls.length;
+    const hasCallWithArgs = spy.mock.calls.some(
+      (callArg) => equals(callArg, args, [...customTesters, iterableEquality])
+    );
+    const pass = hasCallWithArgs && callCount === 1;
+    const isNot = utils.flag(this, "negate");
+    const msg = utils.getMessage(this, [
+      pass,
+      `expected "${spyName}" to be called once with arguments: #{exp}`,
+      `expected "${spyName}" to not be called once with arguments: #{exp}`,
+      args
+    ]);
+    if (pass && isNot || !pass && !isNot) {
+      throw new AssertionError(formatCalls(spy, msg, args));
+    }
+  });
   def(
     ["toHaveBeenNthCalledWith", "nthCalledWith"],
     function(times, ...args) {
@@ -1502,6 +1521,61 @@ const JestChaiExpect = (chai, utils) => {
       );
     }
   );
+  function isSpyCalledBeforeAnotherSpy(beforeSpy, afterSpy, failIfNoFirstInvocation) {
+    const beforeInvocationCallOrder = beforeSpy.mock.invocationCallOrder;
+    const afterInvocationCallOrder = afterSpy.mock.invocationCallOrder;
+    if (beforeInvocationCallOrder.length === 0) {
+      return !failIfNoFirstInvocation;
+    }
+    if (afterInvocationCallOrder.length === 0) {
+      return false;
+    }
+    return beforeInvocationCallOrder[0] < afterInvocationCallOrder[0];
+  }
+  def(
+    ["toHaveBeenCalledBefore"],
+    function(resultSpy, failIfNoFirstInvocation = true) {
+      const expectSpy = getSpy(this);
+      if (!isMockFunction(resultSpy)) {
+        throw new TypeError(
+          `${utils.inspect(resultSpy)} is not a spy or a call to a spy`
+        );
+      }
+      this.assert(
+        isSpyCalledBeforeAnotherSpy(
+          expectSpy,
+          resultSpy,
+          failIfNoFirstInvocation
+        ),
+        `expected "${expectSpy.getMockName()}" to have been called before "${resultSpy.getMockName()}"`,
+        `expected "${expectSpy.getMockName()}" to not have been called before "${resultSpy.getMockName()}"`,
+        resultSpy,
+        expectSpy
+      );
+    }
+  );
+  def(
+    ["toHaveBeenCalledAfter"],
+    function(resultSpy, failIfNoFirstInvocation = true) {
+      const expectSpy = getSpy(this);
+      if (!isMockFunction(resultSpy)) {
+        throw new TypeError(
+          `${utils.inspect(resultSpy)} is not a spy or a call to a spy`
+        );
+      }
+      this.assert(
+        isSpyCalledBeforeAnotherSpy(
+          resultSpy,
+          expectSpy,
+          failIfNoFirstInvocation
+        ),
+        `expected "${expectSpy.getMockName()}" to have been called after "${resultSpy.getMockName()}"`,
+        `expected "${expectSpy.getMockName()}" to not have been called after "${resultSpy.getMockName()}"`,
+        resultSpy,
+        expectSpy
+      );
+    }
+  );
   def(
     ["toThrow", "toThrowError"],
     function(expected) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/expect",
   "type": "module",
-  "version": "2.1.5",
+  "version": "2.2.0-beta.2",
   "description": "Jest's expect matchers as a Chai plugin",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -32,13 +32,13 @@
   "dependencies": {
     "chai": "^5.1.2",
     "tinyrainbow": "^1.2.0",
-    "@vitest/utils": "2.1.5",
-    "@vitest/spy": "2.1.5"
+    "@vitest/spy": "2.2.0-beta.2",
+    "@vitest/utils": "2.2.0-beta.2"
   },
   "devDependencies": {
     "@types/chai": "4.3.6",
     "rollup-plugin-copy": "^3.5.0",
-    "@vitest/runner": "2.1.5"
+    "@vitest/runner": "2.2.0-beta.2"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",