@vitest/expect 4.0.18 → 4.1.0-beta.2

package/dist/index.d.ts

@@ -9,11 +9,6 @@ import { stringify } from '@vitest/utils/display';
 import * as chai from 'chai';
 export { chai };
 
-declare const MATCHERS_OBJECT: unique symbol;
-declare const JEST_MATCHERS_OBJECT: unique symbol;
-declare const GLOBAL_EXPECT: unique symbol;
-declare const ASYMMETRIC_MATCHERS_OBJECT: unique symbol;
-
 interface AsymmetricMatcherInterface {
 	asymmetricMatch: (other: unknown, customTesters?: Array<Tester>) => boolean;
 	toString: () => string;
@@ -131,9 +126,18 @@ interface MatcherState {
 	customTesters: Array<Tester>;
 	assertionCalls: number;
 	currentTestName?: string;
+	/**
+	* @deprecated exists only in types
+	*/
 	dontThrow?: () => void;
+	/**
+	* @deprecated exists only in types
+	*/
 	error?: Error;
 	equals: (a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean) => boolean;
+	/**
+	* @deprecated exists only in types
+	*/
 	expand?: boolean;
 	expectedAssertionsNumber?: number | null;
 	expectedAssertionsNumberErrorGen?: (() => Error) | null;
@@ -141,6 +145,9 @@ interface MatcherState {
 	isExpectingAssertionsError?: Error | null;
 	isNot: boolean;
 	promise: string;
+	/**
+	* @deprecated exists only in types
+	*/
 	suppressedErrors: Array<Error>;
 	testPath?: string;
 	utils: ReturnType<typeof getMatcherUtils> & {
@@ -655,7 +662,7 @@ type VitestAssertion<
 > = { [K in keyof A] : A[K] extends Chai.Assertion ? Assertion<T> : A[K] extends (...args: any[]) => any ? A[K] : VitestAssertion<A[K], T> } & ((type: string, message?: string) => Assertion);
 type Promisify<O> = { [K in keyof O] : O[K] extends (...args: infer A) => infer 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>, Matchers<T> {
+interface Assertion<T = any> extends VitestAssertion<Chai.Assertion, T>, JestAssertion<T>, ChaiMockAssertion, Matchers<T> {
 	/**
 	* Ensures a value is of a specific type.
 	*
@@ -759,6 +766,140 @@ interface Assertion<T = any> extends VitestAssertion<Chai.Assertion, T>, JestAss
 	*/
 	rejects: PromisifyAssertion<T>;
 }
+/**
+* Chai-style assertions for spy/mock testing.
+* These provide sinon-chai compatible assertion names that delegate to Jest-style implementations.
+*/
+interface ChaiMockAssertion {
+	/**
+	* Checks that a spy was called at least once.
+	* Chai-style equivalent of `toHaveBeenCalled`.
+	*
+	* @example
+	* expect(spy).to.have.been.called
+	*/
+	readonly called: Assertion;
+	/**
+	* Checks that a spy was called a specific number of times.
+	* Chai-style equivalent of `toHaveBeenCalledTimes`.
+	*
+	* @example
+	* expect(spy).to.have.callCount(3)
+	*/
+	callCount: (count: number) => void;
+	/**
+	* Checks that a spy was called with specific arguments at least once.
+	* Chai-style equivalent of `toHaveBeenCalledWith`.
+	*
+	* @example
+	* expect(spy).to.have.been.calledWith('arg1', 'arg2')
+	*/
+	calledWith: <E extends any[]>(...args: E) => void;
+	/**
+	* Checks that a spy was called exactly once.
+	* Chai-style equivalent of `toHaveBeenCalledOnce`.
+	*
+	* @example
+	* expect(spy).to.have.been.calledOnce
+	*/
+	readonly calledOnce: Assertion;
+	/**
+	* Checks that a spy was called exactly once with specific arguments.
+	* Chai-style equivalent of `toHaveBeenCalledExactlyOnceWith`.
+	*
+	* @example
+	* expect(spy).to.have.been.calledOnceWith('arg1', 'arg2')
+	*/
+	calledOnceWith: <E extends any[]>(...args: E) => void;
+	/**
+	* Checks that the last call to a spy was made with specific arguments.
+	* Chai-style equivalent of `toHaveBeenLastCalledWith`.
+	*
+	* @example
+	* expect(spy).to.have.been.lastCalledWith('arg1', 'arg2')
+	*/
+	lastCalledWith: <E extends any[]>(...args: E) => void;
+	/**
+	* Checks that the nth call to a spy was made with specific arguments.
+	* Chai-style equivalent of `toHaveBeenNthCalledWith`.
+	*
+	* @example
+	* expect(spy).to.have.been.nthCalledWith(2, 'arg1', 'arg2')
+	*/
+	nthCalledWith: <E extends any[]>(n: number, ...args: E) => void;
+	/**
+	* Checks that a spy returned successfully at least once.
+	* Chai-style equivalent of `toHaveReturned`.
+	*
+	* @example
+	* expect(spy).to.have.returned
+	*/
+	readonly returned: Assertion;
+	/**
+	* Checks that a spy returned a specific value at least once.
+	* Chai-style equivalent of `toHaveReturnedWith`.
+	*
+	* @example
+	* expect(spy).to.have.returnedWith('value')
+	*/
+	returnedWith: <E>(value: E) => void;
+	/**
+	* Checks that a spy returned successfully a specific number of times.
+	* Chai-style equivalent of `toHaveReturnedTimes`.
+	*
+	* @example
+	* expect(spy).to.have.returnedTimes(3)
+	*/
+	returnedTimes: (count: number) => void;
+	/**
+	* Checks that the last return value of a spy matches the expected value.
+	* Chai-style equivalent of `toHaveLastReturnedWith`.
+	*
+	* @example
+	* expect(spy).to.have.lastReturnedWith('value')
+	*/
+	lastReturnedWith: <E>(value: E) => void;
+	/**
+	* Checks that the nth return value of a spy matches the expected value.
+	* Chai-style equivalent of `toHaveNthReturnedWith`.
+	*
+	* @example
+	* expect(spy).to.have.nthReturnedWith(2, 'value')
+	*/
+	nthReturnedWith: <E>(n: number, value: E) => void;
+	/**
+	* Checks that a spy was called before another spy.
+	* Chai-style equivalent of `toHaveBeenCalledBefore`.
+	*
+	* @example
+	* expect(spy1).to.have.been.calledBefore(spy2)
+	*/
+	calledBefore: (mock: MockInstance, failIfNoFirstInvocation?: boolean) => void;
+	/**
+	* Checks that a spy was called after another spy.
+	* Chai-style equivalent of `toHaveBeenCalledAfter`.
+	*
+	* @example
+	* expect(spy1).to.have.been.calledAfter(spy2)
+	*/
+	calledAfter: (mock: MockInstance, failIfNoFirstInvocation?: boolean) => void;
+	/**
+	* Checks that a spy was called exactly twice.
+	* Chai-style equivalent of `toHaveBeenCalledTimes(2)`.
+	*
+	* @example
+	* expect(spy).to.have.been.calledTwice
+	*/
+	readonly calledTwice: Assertion;
+	/**
+	* Checks that a spy was called exactly three times.
+	* Chai-style equivalent of `toHaveBeenCalledTimes(3)`.
+	*
+	* @example
+	* expect(spy).to.have.been.calledThrice
+	*/
+	readonly calledThrice: Assertion;
+}
 declare global {
 	namespace jest {
 		interface Matchers<
@@ -768,6 +909,13 @@ declare global {
 	}
 }
 
+declare const ChaiStyleAssertions: ChaiPlugin;
+
+declare const MATCHERS_OBJECT: unique symbol;
+declare const JEST_MATCHERS_OBJECT: unique symbol;
+declare const GLOBAL_EXPECT: unique symbol;
+declare const ASYMMETRIC_MATCHERS_OBJECT: unique symbol;
+
 declare const customMatchers: MatchersObject;
 
 declare const JestChaiExpect: ChaiPlugin;
@@ -802,5 +950,5 @@ declare function isStandardSchema(obj: any): obj is StandardSchemaV1;
 declare function getState<State extends MatcherState = MatcherState>(expect: ExpectStatic): State;
 declare function setState<State extends MatcherState = MatcherState>(state: Partial<State>, expect: ExpectStatic): void;
 
-export { ASYMMETRIC_MATCHERS_OBJECT, Any, Anything, ArrayContaining, AsymmetricMatcher, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, ObjectContaining, SchemaMatching, StringContaining, StringMatching, addCustomEqualityTesters, arrayBufferEquality, customMatchers, equals, fnNameFor, generateToBeMessage, getObjectKeys, getObjectSubset, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isImmutableUnorderedKeyed, isImmutableUnorderedSet, isStandardSchema, iterableEquality, pluralize, setState, sparseArrayEquality, subsetEquality, typeEquality };
-export type { Assertion, AsymmetricMatcherInterface, AsymmetricMatchersContaining, AsyncExpectationResult, ChaiPlugin, DeeplyAllowMatchers, ExpectStatic, ExpectationResult, JestAssertion, MatcherHintOptions, MatcherState, Matchers, MatchersObject, PromisifyAssertion, RawMatcherFn, SyncExpectationResult, Tester, TesterContext };
+export { ASYMMETRIC_MATCHERS_OBJECT, Any, Anything, ArrayContaining, AsymmetricMatcher, ChaiStyleAssertions, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, ObjectContaining, SchemaMatching, StringContaining, StringMatching, addCustomEqualityTesters, arrayBufferEquality, customMatchers, equals, fnNameFor, generateToBeMessage, getObjectKeys, getObjectSubset, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isImmutableUnorderedKeyed, isImmutableUnorderedSet, isStandardSchema, iterableEquality, pluralize, setState, sparseArrayEquality, subsetEquality, typeEquality };
+export type { Assertion, AsymmetricMatcherInterface, AsymmetricMatchersContaining, AsyncExpectationResult, ChaiMockAssertion, ChaiPlugin, DeeplyAllowMatchers, ExpectStatic, ExpectationResult, JestAssertion, MatcherHintOptions, MatcherState, Matchers, MatchersObject, PromisifyAssertion, RawMatcherFn, SyncExpectationResult, Tester, TesterContext };

package/dist/index.js

@@ -8,6 +8,52 @@ import { use, util } from 'chai';
 import * as chai from 'chai';
 export { chai };
 
+const ChaiStyleAssertions = (chai, utils) => {
+	function defProperty(name, delegateTo) {
+		utils.addProperty(chai.Assertion.prototype, name, function() {
+			const jestMethod = chai.Assertion.prototype[delegateTo];
+			if (!jestMethod) {
+				throw new Error(`Cannot delegate to ${String(delegateTo)}: method not found. Ensure JestChaiExpect plugin is loaded first.`);
+			}
+			return jestMethod.call(this);
+		});
+	}
+	function defPropertyWithArgs(name, delegateTo, ...args) {
+		utils.addProperty(chai.Assertion.prototype, name, function() {
+			const jestMethod = chai.Assertion.prototype[delegateTo];
+			if (!jestMethod) {
+				throw new Error(`Cannot delegate to ${String(delegateTo)}: method not found. Ensure JestChaiExpect plugin is loaded first.`);
+			}
+			return jestMethod.call(this, ...args);
+		});
+	}
+	function defMethod(name, delegateTo) {
+		utils.addChainableMethod(chai.Assertion.prototype, name, function(...args) {
+			const jestMethod = chai.Assertion.prototype[delegateTo];
+			if (!jestMethod) {
+				throw new Error(`Cannot delegate to ${String(delegateTo)}: method not found. Ensure JestChaiExpect plugin is loaded first.`);
+			}
+			return jestMethod.call(this, ...args);
+		}, () => {});
+	}
+	defProperty("called", "toHaveBeenCalled");
+	defProperty("calledOnce", "toHaveBeenCalledOnce");
+	defProperty("returned", "toHaveReturned");
+	defPropertyWithArgs("calledTwice", "toHaveBeenCalledTimes", 2);
+	defPropertyWithArgs("calledThrice", "toHaveBeenCalledTimes", 3);
+	defMethod("callCount", "toHaveBeenCalledTimes");
+	defMethod("calledWith", "toHaveBeenCalledWith");
+	defMethod("calledOnceWith", "toHaveBeenCalledExactlyOnceWith");
+	defMethod("lastCalledWith", "toHaveBeenLastCalledWith");
+	defMethod("nthCalledWith", "toHaveBeenNthCalledWith");
+	defMethod("returnedWith", "toHaveReturnedWith");
+	defMethod("returnedTimes", "toHaveReturnedTimes");
+	defMethod("lastReturnedWith", "toHaveLastReturnedWith");
+	defMethod("nthReturnedWith", "toHaveNthReturnedWith");
+	defMethod("calledBefore", "toHaveBeenCalledBefore");
+	defMethod("calledAfter", "toHaveBeenCalledAfter");
+};
+
 const MATCHERS_OBJECT = Symbol.for("matchers-object");
 const JEST_MATCHERS_OBJECT = Symbol.for("$$jest-matchers-object");
 const GLOBAL_EXPECT = Symbol.for("expect-global");
@@ -1872,4 +1918,4 @@ const JestExtend = (chai, utils) => {
 	});
 };
 
-export { ASYMMETRIC_MATCHERS_OBJECT, Any, Anything, ArrayContaining, AsymmetricMatcher, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, ObjectContaining, SchemaMatching, StringContaining, StringMatching, addCustomEqualityTesters, arrayBufferEquality, customMatchers, equals, fnNameFor, generateToBeMessage, getObjectKeys, getObjectSubset, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isImmutableUnorderedKeyed, isImmutableUnorderedSet, isStandardSchema, iterableEquality, pluralize, setState, sparseArrayEquality, subsetEquality, typeEquality };
+export { ASYMMETRIC_MATCHERS_OBJECT, Any, Anything, ArrayContaining, AsymmetricMatcher, ChaiStyleAssertions, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, ObjectContaining, SchemaMatching, StringContaining, StringMatching, addCustomEqualityTesters, arrayBufferEquality, customMatchers, equals, fnNameFor, generateToBeMessage, getObjectKeys, getObjectSubset, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isImmutableUnorderedKeyed, isImmutableUnorderedSet, isStandardSchema, iterableEquality, pluralize, setState, sparseArrayEquality, subsetEquality, typeEquality };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/expect",
   "type": "module",
-  "version": "4.0.18",
+  "version": "4.1.0-beta.2",
   "description": "Jest's expect matchers as a Chai plugin",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -29,15 +29,15 @@
     "dist"
   ],
   "dependencies": {
-    "@standard-schema/spec": "^1.0.0",
+    "@standard-schema/spec": "^1.1.0",
     "@types/chai": "^5.2.2",
-    "chai": "^6.2.1",
+    "chai": "^6.2.2",
     "tinyrainbow": "^3.0.3",
-    "@vitest/spy": "4.0.18",
-    "@vitest/utils": "4.0.18"
+    "@vitest/spy": "4.1.0-beta.2",
+    "@vitest/utils": "4.1.0-beta.2"
   },
   "devDependencies": {
-    "@vitest/runner": "4.0.18"
+    "@vitest/runner": "4.1.0-beta.2"
   },
   "scripts": {
     "build": "premove dist && rollup -c",