vitest 0.0.120 → 0.0.121

package/dist/cli.js

@@ -8,7 +8,7 @@ import { m as mergeStream, g as getStream, c as crossSpawn } from './index-6e709
 import require$$0, { constants } from 'os';
 import { s as signalExit } from './index-648e7ab2.js';
 import { e as ensurePackageInstalled } from './index-090545ef.js';
-import { c as createVitest } from './index-df5396e4.js';
+import { c as createVitest } from './index-123a18df.js';
 import './_commonjsHelpers-c9e3b764.js';
 import 'fs';
 import 'stream';
@@ -1700,11 +1700,11 @@ function execa(file, args, options) {
 	return mergePromise(spawned, handlePromiseOnce);
 }
 
-var version = "0.0.120";
+var version = "0.0.121";
 
 const CLOSE_TIMEOUT = 1e3;
 const cli = cac("vitest");
-cli.version(version).option("-r, --root <path>", "root path").option("-c, --config <path>", "path to config file").option("-u, --update", "update snapshot").option("-w, --watch", "watch mode").option("-o, --open", "open UI", { default: false }).option("-t, --testNamePattern <pattern>", "run test names with the specified pattern").option("--api", "listen to port and serve API").option("--threads", "enabled threads", { default: true }).option("--silent", "silent console output from tests").option("--reporter <name>", "reporter").option("--coverage", "use c8 for coverage").option("--run", "do not watch").option("--global", "inject apis globally").option("--dom", "mock browser api with happy-dom").option("--environment <env>", "runner environment", { default: "node" }).option("--passWithNoTests", "pass when no tests found").help();
+cli.version(version).option("-r, --root <path>", "root path").option("-c, --config <path>", "path to config file").option("-u, --update", "update snapshot").option("-w, --watch", "watch mode").option("-o, --open", "open UI", { default: false }).option("-t, --testNamePattern <pattern>", "run test names with the specified pattern").option("--api", "listen to port and serve API").option("--threads", "enabled threads", { default: true }).option("--silent", "silent console output from tests").option("--reporter <name>", "reporter").option("--coverage", "use c8 for coverage").option("--run", "do not watch").option("--global", "inject apis globally").option("--dom", "mock browser api with happy-dom").option("--findRelatedTests <filepath>", "run only tests that import specified file").option("--environment <env>", "runner environment", { default: "node" }).option("--passWithNoTests", "pass when no tests found").help();
 cli.command("run [...filters]").action(run);
 cli.command("watch [...filters]").action(dev);
 cli.command("dev [...filters]").action(dev);

package/dist/entry.js

@@ -1,5 +1,5 @@
 import fs, { promises } from 'fs';
-import { f as equals, h as iterableEquality, j as subsetEquality, k as isA, J as JestChaiExpect, l as clearContext, m as defaultSuite, n as setHooks, o as getHooks, p as context, s as setState, q as getFn, b as getState, e as vi } from './vi-67a5a3b3.js';
+import { b as getState, f as equals, h as iterableEquality, j as subsetEquality, k as isA, J as JestChaiExpect, l as clearContext, m as defaultSuite, n as setHooks, o as getHooks, p as context, s as setState, q as getFn, e as vi } from './vi-db2bc738.js';
 import { Console } from 'console';
 import { Writable } from 'stream';
 import { importModule } from 'local-pkg';
@@ -3283,18 +3283,19 @@ const isAsyncFunction = (fn) => typeof fn === "function" && fn[Symbol.toStringTa
 const getMatcherState = (assertion) => {
   const actual = assertion._obj;
   const isNot = util.flag(assertion, "negate");
+  const promise = util.flag(assertion, "promise") || "";
   const jestUtils = __spreadProps(__spreadValues({}, matcherUtils), {
     iterableEquality,
     subsetEquality
   });
-  const matcherState = {
+  const matcherState = __spreadProps(__spreadValues({
     isNot,
     utils: jestUtils,
-    assertionCalls: 0,
-    promise: "",
-    equals,
+    promise,
+    equals
+  }, getState()), {
     suppressedErrors: []
-  };
+  });
   return {
     state: matcherState,
     isNot,
@@ -3494,22 +3495,18 @@ class StringMatching extends AsymmetricMatcher {
   }
 }
 const JestAsymmetricMatchers = (chai, utils) => {
+  utils.addMethod(chai.expect, "anything", () => new Anything());
+  utils.addMethod(chai.expect, "any", (expected) => new Any(expected));
   utils.addMethod(chai.expect, "stringContaining", (expected) => new StringContaining(expected));
-  utils.addMethod(chai.expect, "anything", () => {
-    return new Anything();
-  });
-  utils.addMethod(chai.expect, "objectContaining", (expected) => {
-    return new ObjectContaining(expected);
-  });
-  utils.addMethod(chai.expect, "any", (expected) => {
-    return new Any(expected);
-  });
-  utils.addMethod(chai.expect, "arrayContaining", (expected) => {
-    return new ArrayContaining(expected);
-  });
-  utils.addMethod(chai.expect, "stringMatching", (expected) => {
-    return new StringMatching(expected);
-  });
+  utils.addMethod(chai.expect, "objectContaining", (expected) => new ObjectContaining(expected));
+  utils.addMethod(chai.expect, "arrayContaining", (expected) => new ArrayContaining(expected));
+  utils.addMethod(chai.expect, "stringMatching", (expected) => new StringMatching(expected));
+  chai.expect.not = {
+    stringContaining: (expected) => new StringContaining(expected, true),
+    objectContaining: (expected) => new ObjectContaining(expected, true),
+    arrayContaining: (expected) => new ArrayContaining(expected, true),
+    stringMatching: (expected) => new StringMatching(expected, true)
+  };
 };
 
 let installed = false;
@@ -3532,7 +3529,7 @@ async function setupGlobalEnv(config) {
   setupConsoleLogSpy();
   await setupChai();
   if (config.global)
-    (await import('./global-9532b920.js')).registerApiGlobally();
+    (await import('./global-f5814404.js')).registerApiGlobally();
 }
 function setupConsoleLogSpy() {
   const stdout = new Writable({
@@ -3624,6 +3621,9 @@ function processError(err) {
 function hash(str, length = 10) {
   return createHash("md5").update(str).digest("hex").slice(0, length);
 }
+function inModuleGraph(files) {
+  return files.some((file) => process.__vitest_worker__.moduleCache.has(file));
+}
 async function collectTests(paths, config) {
   const files = [];
   for (const filepath of paths) {
@@ -3641,6 +3641,8 @@ async function collectTests(paths, config) {
     try {
       await runSetupFiles(config);
       await import(filepath);
+      if (config.findRelatedTests && !inModuleGraph(config.findRelatedTests))
+        continue;
       const defaultTasks = await defaultSuite.collect(file);
       setHooks(file, getHooks(defaultTasks));
       for (const c of [...defaultTasks.tasks, ...context.tasks]) {
@@ -3755,11 +3757,19 @@ async function runTest(test) {
   process.__vitest_worker__.current = test;
   try {
     await callSuiteHook(test.suite, "beforeEach", [test, test.suite]);
-    setState({ assertionCalls: 0, expectedAssertionsNumber: null, expectedAssertionsNumberError: null });
+    setState({
+      assertionCalls: 0,
+      isExpectingAssertions: false,
+      isExpectingAssertionsError: null,
+      expectedAssertionsNumber: null,
+      expectedAssertionsNumberError: null
+    });
     await getFn(test)();
-    const { assertionCalls, expectedAssertionsNumber, expectedAssertionsNumberError } = getState();
+    const { assertionCalls, expectedAssertionsNumber, expectedAssertionsNumberError, isExpectingAssertions, isExpectingAssertionsError } = getState();
     if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber)
       throw expectedAssertionsNumberError;
+    if (isExpectingAssertions === true && assertionCalls === 0)
+      throw isExpectingAssertionsError;
     test.result.state = "pass";
   } catch (e) {
     test.result.state = "fail";

package/dist/{global-9532b920.js → global-f5814404.js}

@@ -1,11 +1,11 @@
 import { g as globalApis } from './constants-22bbd600.js';
-import { i as index } from './index-ea959009.js';
+import { i as index } from './index-32bc2073.js';
 import 'url';
 import './index-090545ef.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
-import './vi-67a5a3b3.js';
+import './vi-db2bc738.js';
 import './_commonjsHelpers-c9e3b764.js';
 import './jest-mock-038a01b3.js';
 import 'chai';

package/dist/{index-df5396e4.js → index-123a18df.js}

@@ -7980,6 +7980,8 @@ function resolveConfig(options, viteConfig) {
   resolved.setupFiles = Array.from(resolved.setupFiles || []).map((i) => resolve(resolved.root, i));
   if (resolved.api === true)
     resolved.api = defaultPort;
+  if (options.findRelatedTests)
+    resolved.findRelatedTests = toArray(options.findRelatedTests).map((file) => resolve(resolved.root, file));
   return resolved;
 }
 

package/dist/{index-ea959009.js → index-32bc2073.js}

@@ -1,4 +1,4 @@
-import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, b as getState, s as setState, c as suite, t as test, d as describe, i as it, v as vitest, e as vi } from './vi-67a5a3b3.js';
+import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, b as getState, s as setState, c as suite, t as test, d as describe, i as it, v as vitest, e as vi } from './vi-db2bc738.js';
 import chai, { assert, should } from 'chai';
 import { s as spies, a as spyOn, f as fn } from './jest-mock-038a01b3.js';
 

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import { ViteDevServer } from 'vite';
 import { RawSourceMap } from 'source-map-js';
 import { OptionsReceived } from 'pretty-format';
 import { MessagePort } from 'worker_threads';
+import { SpyImpl } from 'tinyspy';
 export { Spy, SpyFn } from 'tinyspy';
 export { assert, default as chai, should } from 'chai';
 
@@ -85,9 +86,9 @@ declare type MatcherState = {
     equals: (a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean) => boolean;
     expand?: boolean;
     expectedAssertionsNumber?: number | null;
-    expectedAssertionsNumberError?: Error;
+    expectedAssertionsNumberError?: Error | null;
     isExpectingAssertions?: boolean;
-    isExpectingAssertionsError?: Error;
+    isExpectingAssertionsError?: Error | null;
     isNot: boolean;
     promise: string;
     suppressedErrors: Array<Error>;
@@ -677,11 +678,16 @@ interface UserConfig extends InlineConfig {
      * Pass with no tests
      */
     passWithNoTests?: boolean;
+    /**
+     * Run tests that cover a list of source files
+     */
+    findRelatedTests?: string[] | string;
 }
-interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters' | 'coverage' | 'testNamePattern'> {
+interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters' | 'coverage' | 'testNamePattern' | 'findRelatedTests'> {
     config?: string;
     filters?: string[];
     testNamePattern?: RegExp;
+    findRelatedTests?: string[];
     depsInline: (string | RegExp)[];
     depsExternal: (string | RegExp)[];
     coverage: ResolvedC8Options;
@@ -782,6 +788,7 @@ declare type MockedObjectDeep<T> = MaybeMockedConstructor<T> & {
 };
 declare type MaybeMockedDeep<T> = T extends MockableFunction ? MockedFunctionDeep<T> : T extends object ? MockedObjectDeep<T> : T;
 declare type MaybeMocked<T> = T extends MockableFunction ? MockedFunction<T> : T extends object ? MockedObject<T> : T;
+declare type EnhancedSpy<TArgs extends any[] = any[], TReturns = any> = JestMockCompat<TArgs, TReturns> & SpyImpl<TArgs, TReturns>;
 interface MockWithArgs<T extends MockableFunction> extends JestMockCompatFn<ArgumentsOf<T>, ReturnType<T>> {
     new (...args: ConstructorArgumentsOf<T>): T;
     (...args: ArgumentsOf<T>): ReturnType<T>;
@@ -891,69 +898,80 @@ declare module 'vite' {
         test?: VitestInlineConfig;
     }
 }
+interface AsymmetricMatchersContaining {
+    stringContaining(expected: string): void;
+    objectContaining(expected: any): ObjectContaining;
+    arrayContaining(expected: unknown[]): ArrayContaining;
+    stringMatching(expected: string | RegExp): StringMatching;
+}
 declare global {
     namespace Chai {
-        interface ExpectStatic {
+        interface ExpectStatic extends AsymmetricMatchersContaining {
             extend(expects: MatchersObject): void;
-            stringContaining(expected: string): void;
+            assertions(expected: number): void;
+            hasAssertions(): void;
             anything(): Anything;
-            objectContaining(expected: any): ObjectContaining;
             any(constructor: unknown): Any;
-            arrayContaining(expected: any): ArrayContaining;
-            stringMatching(expected: RegExp): StringMatching;
-            assertions(expected: number): void;
+            not: AsymmetricMatchersContaining;
+        }
+        interface JestAssertions<T = void> {
+            toMatchSnapshot(message?: string): T;
+            toMatchInlineSnapshot(snapshot?: string, message?: string): T;
+            matchSnapshot(message?: string): T;
+            toEqual(expected: any): T;
+            toStrictEqual(expected: any): T;
+            toBe(expected: any): T;
+            toMatch(expected: string | RegExp): T;
+            toMatchObject(expected: any): T;
+            toContain(item: any): T;
+            toContainEqual(item: any): T;
+            toBeTruthy(): T;
+            toBeFalsy(): T;
+            toBeGreaterThan(num: number): T;
+            toBeGreaterThanOrEqual(num: number): T;
+            toBeLessThan(num: number): T;
+            toBeLessThanOrEqual(num: number): T;
+            toBeNaN(): T;
+            toBeUndefined(): T;
+            toBeNull(): T;
+            toBeDefined(): T;
+            toBeInstanceOf(c: any): T;
+            toBeCalledTimes(n: number): T;
+            toHaveLength(l: number): T;
+            toHaveProperty(p: string, value?: any): T;
+            toBeCloseTo(number: number, numDigits?: number): T;
+            toHaveBeenCalledTimes(n: number): T;
+            toHaveBeenCalledOnce(): T;
+            toHaveBeenCalled(): T;
+            toBeCalled(): T;
+            toHaveBeenCalledWith(...args: any[]): T;
+            toBeCalledWith(...args: any[]): T;
+            toHaveBeenNthCalledWith(n: number, ...args: any[]): T;
+            nthCalledWith(n: number, ...args: any[]): T;
+            toHaveBeenLastCalledWith(...args: any[]): T;
+            lastCalledWith(...args: any[]): T;
+            toThrow(expected?: string | RegExp): T;
+            toThrowError(expected?: string | RegExp): T;
+            toReturn(): T;
+            toHaveReturned(): T;
+            toReturnTimes(times: number): T;
+            toHaveReturnedTimes(times: number): T;
+            toReturnWith(value: any): T;
+            toHaveReturnedWith(value: any): T;
+            toHaveLastReturnedWith(value: any): T;
+            lastReturnedWith(value: any): T;
+            toHaveNthReturnedWith(nthCall: number, value: any): T;
+            nthReturnedWith(nthCall: number, value: any): T;
         }
-        interface Assertion {
+        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];
+        };
+        interface Assertion extends JestAssertions {
+            resolves: Promisify<Assertion>;
+            rejects: Promisify<Assertion>;
             chaiEqual(expected: any): void;
-            toMatchSnapshot(message?: string): Assertion;
-            toMatchInlineSnapshot(snapshot?: string, message?: string): Assertion;
-            matchSnapshot(message?: string): Assertion;
-            toEqual(expected: any): void;
-            toStrictEqual(expected: any): void;
-            toBe(expected: any): void;
-            toMatch(expected: string | RegExp): void;
-            toMatchObject(expected: any): void;
-            toContain(item: any): void;
-            toContainEqual(item: any): void;
-            toBeTruthy(): void;
-            toBeFalsy(): void;
-            toBeGreaterThan(num: number): void;
-            toBeGreaterThanOrEqual(num: number): void;
-            toBeLessThan(num: number): void;
-            toBeLessThanOrEqual(num: number): void;
-            toBeNaN(): void;
-            toBeUndefined(): void;
-            toBeNull(): void;
-            toBeDefined(): void;
-            toBeInstanceOf(c: any): void;
-            toBeCalledTimes(n: number): void;
-            toHaveLength(l: number): void;
-            toHaveProperty(p: string, value?: any): void;
-            toBeCloseTo(number: number, numDigits?: number): void;
-            toHaveBeenCalledTimes(n: number): void;
-            toHaveBeenCalledOnce(): void;
-            toHaveBeenCalled(): void;
-            toBeCalled(): void;
-            toHaveBeenCalledWith(...args: any[]): void;
-            toBeCalledWith(...args: any[]): void;
-            toHaveBeenNthCalledWith(n: number, ...args: any[]): void;
-            nthCalledWith(n: number, ...args: any[]): void;
-            toHaveBeenLastCalledWith(...args: any[]): void;
-            lastCalledWith(...args: any[]): void;
-            toThrow(expected?: string | RegExp): void;
-            toThrowError(expected?: string | RegExp): void;
-            toReturn(): void;
-            toHaveReturned(): void;
-            toReturnTimes(times: number): void;
-            toHaveReturnedTimes(times: number): void;
-            toReturnWith(value: any): void;
-            toHaveReturnedWith(value: any): void;
-            toHaveLastReturnedWith(value: any): void;
-            lastReturnedWith(value: any): void;
-            toHaveNthReturnedWith(nthCall: number, value: any): void;
-            nthReturnedWith(nthCall: number, value: any): void;
         }
     }
 }
 
-export { ArgumentsOf, ArgumentsType, Arrayable, Awaitable, BuiltinEnvironment, ComputeMode, ConstructorArgumentsOf, DoneCallback, Environment, EnvironmentReturn, File, HookListener, InlineConfig, JestMockCompat, JestMockCompatContext, JestMockCompatFn, MaybeMocked, MaybeMockedConstructor, MaybeMockedDeep, MethodKeysOf, MockWithArgs, MockableFunction, MockedFunction, MockedFunctionDeep, MockedObject, MockedObjectDeep, ModuleCache, Nullable, ParsedStack, Position, PropertyKeysOf, Reporter, ResolvedConfig, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, Suite, SuiteCollector, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestCollector, TestFactory, TestFunction, UncheckedSnapshot, UserConfig, UserConsoleLog, WebSocketEvents, WebSocketHandlers, WorkerContext, WorkerRPC, afterAll, afterEach, beforeAll, beforeEach, describe, expect, fn, it, spies, spyOn, suite, test, vi, vitest };
+export { ArgumentsOf, ArgumentsType, Arrayable, Awaitable, BuiltinEnvironment, ComputeMode, ConstructorArgumentsOf, DoneCallback, EnhancedSpy, Environment, EnvironmentReturn, File, HookListener, InlineConfig, JestMockCompat, JestMockCompatContext, JestMockCompatFn, MaybeMocked, MaybeMockedConstructor, MaybeMockedDeep, MethodKeysOf, MockWithArgs, MockableFunction, MockedFunction, MockedFunctionDeep, MockedObject, MockedObjectDeep, ModuleCache, Nullable, ParsedStack, Position, PropertyKeysOf, Reporter, ResolvedConfig, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, Suite, SuiteCollector, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestCollector, TestFactory, TestFunction, UncheckedSnapshot, UserConfig, UserConsoleLog, WebSocketEvents, WebSocketHandlers, WorkerContext, WorkerRPC, afterAll, afterEach, beforeAll, beforeEach, describe, expect, fn, it, spies, spyOn, suite, test, vi, vitest };

package/dist/index.js

@@ -1,5 +1,5 @@
-export { d as describe, i as it, c as suite, t as test, e as vi, v as vitest } from './vi-67a5a3b3.js';
-export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, e as expect } from './index-ea959009.js';
+export { d as describe, i as it, c as suite, t as test, e as vi, v as vitest } from './vi-db2bc738.js';
+export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, e as expect } from './index-32bc2073.js';
 export { f as fn, s as spies, a as spyOn } from './jest-mock-038a01b3.js';
 export { assert, default as chai, should } from 'chai';
 import './index-090545ef.js';

package/dist/node.d.ts

@@ -386,11 +386,16 @@ interface UserConfig extends InlineConfig {
      * Pass with no tests
      */
     passWithNoTests?: boolean;
+    /**
+     * Run tests that cover a list of source files
+     */
+    findRelatedTests?: string[] | string;
 }
-interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters' | 'coverage' | 'testNamePattern'> {
+interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters' | 'coverage' | 'testNamePattern' | 'findRelatedTests'> {
     config?: string;
     filters?: string[];
     testNamePattern?: RegExp;
+    findRelatedTests?: string[];
     depsInline: (string | RegExp)[];
     depsExternal: (string | RegExp)[];
     coverage: ResolvedC8Options;

package/dist/node.js

@@ -1,4 +1,4 @@
-export { c as createVitest } from './index-df5396e4.js';
+export { c as createVitest } from './index-123a18df.js';
 import './index-090545ef.js';
 import 'url';
 import 'tty';

package/dist/{vi-67a5a3b3.js → vi-db2bc738.js}

@@ -459,6 +459,8 @@ const MATCHERS_OBJECT = Symbol.for("matchers-object");
 if (!Object.prototype.hasOwnProperty.call(global, MATCHERS_OBJECT)) {
   const defaultState = {
     assertionCalls: 0,
+    isExpectingAssertions: false,
+    isExpectingAssertionsError: null,
     expectedAssertionsNumber: null,
     expectedAssertionsNumberError: null
   };
@@ -502,7 +504,7 @@ const JestChaiExpect = (chai, utils) => {
       const expected = args[0];
       const actual = utils.flag(this, "object");
       if (hasAsymmetric(expected)) {
-        this.assert(equals(actual, expected), "not match with #{exp}", "should not match with #{exp}", actual, expected);
+        this.assert(equals(actual, expected), "not match with #{exp}", "should not match with #{exp}", expected, actual);
       } else {
         _super.apply(this, args);
       }
@@ -512,7 +514,14 @@ const JestChaiExpect = (chai, utils) => {
     return this.eql(expected);
   });
   def("toStrictEqual", function(expected) {
-    return iterableEquality(this, expected) ?? typeEquality(this, expected) ?? sparseArrayEquality(this, expected) ?? arrayBufferEquality(this, expected);
+    const obj = utils.flag(this, "object");
+    const equal = equals(obj, expected, [
+      iterableEquality,
+      typeEquality,
+      sparseArrayEquality,
+      arrayBufferEquality
+    ], true);
+    return this.assert(equal, "expected #{this} to strictly equal #{exp}", "expected #{this} to not strictly equal #{exp}", expected, obj);
   });
   def("toBe", function(expected) {
     return this.equal(expected);
@@ -571,6 +580,10 @@ const JestChaiExpect = (chai, utils) => {
     return this.be.null;
   });
   def("toBeDefined", function() {
+    const negate = utils.flag(this, "negate");
+    utils.flag(this, "negate", false);
+    if (negate)
+      return this.be.undefined;
     return this.not.be.undefined;
   });
   def("toBeInstanceOf", function(obj) {
@@ -599,20 +612,24 @@ const JestChaiExpect = (chai, utils) => {
   };
   def(["toHaveBeenCalledTimes", "toBeCalledTimes"], function(number) {
     const spy = getSpy(this);
-    return this.assert(spy.callCount === number, "expected spy to be called #{exp} times", "expected spy to not be called #{exp} times", number, spy.callCount);
+    const spyName = spy.getMockName();
+    return this.assert(spy.callCount === number, `expected "${spyName}" to be called #{exp} times`, `expected "${spyName}" to not be called #{exp} times`, number, spy.callCount);
   });
   def("toHaveBeenCalledOnce", function() {
     const spy = getSpy(this);
-    return this.assert(spy.callCount === 1, "expected spy to be called once", "expected spy to not be called once", 1, spy.callCount);
+    const spyName = spy.getMockName();
+    return this.assert(spy.callCount === 1, `expected "${spyName}" to be called once`, `expected "${spyName}" to not be called once`, 1, spy.callCount);
   });
   def(["toHaveBeenCalled", "toBeCalled"], function() {
     const spy = getSpy(this);
-    return this.assert(spy.called, "expected spy to be called at least once", "expected spy to not be called at all", true, spy.called);
+    const spyName = spy.getMockName();
+    return this.assert(spy.called, `expected "${spyName}" to be called at least once`, `expected "${spyName}" to not be called at all`, true, spy.called);
   });
   def(["toHaveBeenCalledWith", "toBeCalledWith"], function(...args) {
     const spy = getSpy(this);
+    const spyName = spy.getMockName();
     const pass = spy.calls.some((callArg) => equals(callArg, args));
-    return this.assert(pass, "expected spy to be called with arguments: #{exp}", "expected spy to not be called with arguments: #{exp}", args, spy.calls);
+    return this.assert(pass, `expected "${spyName}" to be called with arguments: #{exp}`, `expected "${spyName}" to not be called with arguments: #{exp}`, args, spy.calls);
   });
   const ordinalOf = (i) => {
     const j = i % 10;
@@ -627,13 +644,15 @@ const JestChaiExpect = (chai, utils) => {
   };
   def(["toHaveBeenNthCalledWith", "nthCalledWith"], function(times, ...args) {
     const spy = getSpy(this);
+    const spyName = spy.getMockName();
     const nthCall = spy.calls[times - 1];
-    this.assert(equals(nthCall, args), `expected ${ordinalOf(times)} spy call to have been called with #{exp}`, `expected ${ordinalOf(times)} spy call to not have been called with #{exp}`, args, nthCall);
+    this.assert(equals(nthCall, args), `expected ${ordinalOf(times)} "${spyName}" call to have been called with #{exp}`, `expected ${ordinalOf(times)} "${spyName}" call to not have been called with #{exp}`, args, nthCall);
   });
   def(["toHaveBeenLastCalledWith", "lastCalledWith"], function(...args) {
     const spy = getSpy(this);
+    const spyName = spy.getMockName();
     const lastCall = spy.calls[spy.calls.length - 1];
-    this.assert(equals(lastCall, args), "expected last spy call to have been called with #{exp}", "expected last spy call to not have been called with #{exp}", args, lastCall);
+    this.assert(equals(lastCall, args), `expected last "${spyName}" call to have been called with #{exp}`, `expected last "${spyName}" call to not have been called with #{exp}`, args, lastCall);
   });
   def(["toThrow", "toThrowError"], function(expected) {
     const negate = utils.flag(this, "negate");
@@ -644,34 +663,80 @@ const JestChaiExpect = (chai, utils) => {
   });
   def(["toHaveReturned", "toReturn"], function() {
     const spy = getSpy(this);
+    const spyName = spy.getMockName();
     const calledAndNotThrew = spy.called && !spy.results.some(([type]) => type === "error");
-    this.assert(calledAndNotThrew, "expected spy to be successfully called at least once", "expected spy to not be successfully called", calledAndNotThrew, !calledAndNotThrew);
+    this.assert(calledAndNotThrew, `expected "${spyName}" to be successfully called at least once`, `expected "${spyName}" to not be successfully called`, calledAndNotThrew, !calledAndNotThrew);
   });
   def(["toHaveReturnedTimes", "toReturnTimes"], function(times) {
     const spy = getSpy(this);
+    const spyName = spy.getMockName();
     const successfullReturns = spy.results.reduce((success, [type]) => type === "error" ? success : ++success, 0);
-    this.assert(successfullReturns === times, `expected spy to be successfully called ${times} times`, `expected spy to not be successfully called ${times} times`, `expected number of returns: ${times}`, `received number of returns: ${successfullReturns}`);
+    this.assert(successfullReturns === 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: ${successfullReturns}`);
   });
   def(["toHaveReturnedWith", "toReturnWith"], function(value) {
     const spy = getSpy(this);
+    const spyName = spy.getMockName();
     const pass = spy.results.some(([type, result]) => type === "ok" && equals(value, result));
-    this.assert(pass, "expected spy to be successfully called with #{exp}", "expected spy to not be successfully called with #{exp}", value);
+    this.assert(pass, `expected "${spyName}" to be successfully called with #{exp}`, `expected "${spyName}" to not be successfully called with #{exp}`, value);
   });
   def(["toHaveLastReturnedWith", "lastReturnedWith"], function(value) {
     const spy = getSpy(this);
+    const spyName = spy.getMockName();
     const lastResult = spy.returns[spy.returns.length - 1];
     const pass = equals(lastResult, value);
-    this.assert(pass, "expected last spy call to return #{exp}", "expected last spy call to not return #{exp}", value, lastResult);
+    this.assert(pass, `expected last "${spyName}" call to return #{exp}`, `expected last "${spyName}" call to not return #{exp}`, value, lastResult);
   });
   def(["toHaveNthReturnedWith", "nthReturnedWith"], function(nthCall, value) {
     const spy = getSpy(this);
+    const spyName = spy.getMockName();
     const isNot = utils.flag(this, "negate");
     const [callType, callResult] = spy.results[nthCall - 1];
     const ordinalCall = `${ordinalOf(nthCall)} call`;
     if (!isNot && callType === "error")
       chai.assert.fail(`expected ${ordinalCall} to return #{exp}, but instead it threw an error`);
     const nthCallReturn = equals(callResult, value);
-    this.assert(nthCallReturn, `expected ${ordinalCall} spy call to return #{exp}`, `expected ${ordinalCall} spy call to not return #{exp}`, value, callResult);
+    this.assert(nthCallReturn, `expected ${ordinalCall} "${spyName}" call to return #{exp}`, `expected ${ordinalCall} "${spyName}" call to not return #{exp}`, value, callResult);
+  });
+  utils.addProperty(chai.Assertion.prototype, "resolves", function() {
+    utils.flag(this, "promise", "resolves");
+    const obj = utils.flag(this, "object");
+    const proxy = new Proxy(this, {
+      get: (target, key, reciever) => {
+        const result = Reflect.get(target, key, reciever);
+        if (typeof result !== "function")
+          return result instanceof chai.Assertion ? proxy : result;
+        return async (...args) => {
+          return obj.then((value) => {
+            utils.flag(this, "object", value);
+            return result.call(this, ...args);
+          }, (err) => {
+            throw new Error(`promise rejected ${err} instead of resolving`);
+          });
+        };
+      }
+    });
+    return proxy;
+  });
+  utils.addProperty(chai.Assertion.prototype, "rejects", function() {
+    utils.flag(this, "promise", "rejects");
+    const obj = utils.flag(this, "object");
+    const wrapper = typeof obj === "function" ? obj() : obj;
+    const proxy = new Proxy(this, {
+      get: (target, key, reciever) => {
+        const result = Reflect.get(target, key, reciever);
+        if (typeof result !== "function")
+          return result instanceof chai.Assertion ? proxy : result;
+        return async (...args) => {
+          return wrapper.then((value) => {
+            throw new Error(`promise resolved ${value} instead of rejecting`);
+          }, (err) => {
+            utils.flag(this, "object", err);
+            return result.call(this, ...args);
+          });
+        };
+      }
+    });
+    return proxy;
   });
   utils.addMethod(chai.expect, "assertions", function assertions(expected) {
     const error = new Error(`expected number of assertions to be ${expected}, but got ${getState().assertionCalls}`);
@@ -682,6 +747,15 @@ const JestChaiExpect = (chai, utils) => {
       expectedAssertionsNumberError: error
     });
   });
+  utils.addMethod(chai.expect, "hasAssertions", function hasAssertions() {
+    const error = new Error("expected any number of assertion, but got none");
+    if (Error.captureStackTrace)
+      Error.captureStackTrace(error, hasAssertions);
+    setState({
+      isExpectingAssertions: true,
+      isExpectingAssertionsError: error
+    });
+  });
 };
 
 var mockdate$1 = {exports: {}};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest",
-  "version": "0.0.120",
+  "version": "0.0.121",
   "description": "A blazing fast unit test framework powered by Vite",
   "keywords": [
     "vite",