vitest 0.0.117 → 0.0.121

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>;
@@ -177,8 +178,8 @@ interface WorkerPool {
 }
 
 declare class StateManager {
-    filesMap: Record<string, File>;
-    idMap: Record<string, Task>;
+    filesMap: Map<string, File>;
+    idMap: Map<string, Task>;
     taskFileMap: WeakMap<Task, File>;
     getFiles(keys?: string[]): File[];
     collectFiles(files?: File[]): void;
@@ -204,6 +205,7 @@ declare class Vitest {
     changedTests: Set<string>;
     visitedFilesMap: Map<string, RawSourceMap>;
     runningPromise?: Promise<void>;
+    closingPromise?: Promise<void>;
     isFirstRun: boolean;
     restartsCount: number;
     private _onRestartListeners;
@@ -624,6 +626,10 @@ interface InlineConfig {
      * @internal WIP
      */
     open?: boolean;
+    /**
+     * run test names with the specified pattern
+     */
+    testNamePattern?: string | RegExp;
     /**
      * Listen to port and serve API
      *
@@ -672,10 +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'> {
+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;
@@ -776,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>;
@@ -866,6 +879,15 @@ declare class VitestUtils {
 declare const vitest: VitestUtils;
 declare const vi: VitestUtils;
 
+interface WebSocketHandlers {
+    getFiles(): File[];
+    getConfig(): ResolvedConfig;
+    getSourceCode(id: string): Promise<string>;
+    rerun(files: string[]): Promise<void>;
+}
+interface WebSocketEvents extends Pick<Reporter, 'onCollected' | 'onTaskUpdate'> {
+}
+
 declare type VitestInlineConfig = InlineConfig;
 
 declare module 'vite' {
@@ -876,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, 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,8 +1,8 @@
-export { d as describe, i as it, c as suite, t as test, e as vi, v as vitest } from './vi-39f06eb7.js';
-export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, e as expect } from './index-2b1f526f.js';
-export { f as fn, s as spies, a as spyOn } from './jest-mock-4a754991.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-bf29f0e6.js';
+import './index-090545ef.js';
 import 'url';
 import 'tty';
 import 'local-pkg';

package/dist/{jest-mock-4a754991.js → jest-mock-038a01b3.js}

@@ -1,7 +1,7 @@
 import { util } from 'chai';
 import * as tinyspy from 'tinyspy';
 
-const spies = /* @__PURE__ */ new Set();
+const spies = new Set();
 function spyOn(obj, method, accessType) {
   const dictionary = {
     get: "getter",

package/dist/node.d.ts

@@ -334,6 +334,10 @@ interface InlineConfig {
      * @internal WIP
      */
     open?: boolean;
+    /**
+     * run test names with the specified pattern
+     */
+    testNamePattern?: string | RegExp;
     /**
      * Listen to port and serve API
      *
@@ -382,10 +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'> {
+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;
@@ -408,8 +418,8 @@ interface WorkerPool {
 }
 
 declare class StateManager {
-    filesMap: Record<string, File>;
-    idMap: Record<string, Task>;
+    filesMap: Map<string, File>;
+    idMap: Map<string, Task>;
     taskFileMap: WeakMap<Task, File>;
     getFiles(keys?: string[]): File[];
     collectFiles(files?: File[]): void;
@@ -435,6 +445,7 @@ declare class Vitest {
     changedTests: Set<string>;
     visitedFilesMap: Map<string, RawSourceMap>;
     runningPromise?: Promise<void>;
+    closingPromise?: Promise<void>;
     isFirstRun: boolean;
     restartsCount: number;
     private _onRestartListeners;

package/dist/node.js

@@ -1,5 +1,5 @@
-export { c as createVitest } from './index-33d800eb.js';
-import './index-bf29f0e6.js';
+export { c as createVitest } from './index-123a18df.js';
+import './index-090545ef.js';
 import 'url';
 import 'tty';
 import 'local-pkg';
@@ -11,10 +11,10 @@ import 'os';
 import 'util';
 import 'stream';
 import 'events';
-import './constants-080f26e8.js';
+import './constants-22bbd600.js';
 import './magic-string.es-94000aea.js';
 import 'perf_hooks';
-import './diff-80c47cfa.js';
+import './diff-a295cb37.js';
 import './index-648e7ab2.js';
 import './_commonjsHelpers-c9e3b764.js';
 import 'assert';

package/dist/{setup-95b119ff.js → setup-c9c7cb5b.js}

@@ -9,8 +9,8 @@ import require$$2 from 'events';
 import require$$1 from 'https';
 import require$$2$1 from 'http';
 import require$$7 from 'url';
-import { A as API_PATH } from './constants-080f26e8.js';
-import './index-bf29f0e6.js';
+import { A as API_PATH } from './constants-22bbd600.js';
+import './index-090545ef.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
@@ -4248,7 +4248,7 @@ function abortHandshake(socket, code, message, headers) {
 function setup(ctx) {
   var _a;
   const wss = new websocketServer({ noServer: true });
-  const clients = /* @__PURE__ */ new Map();
+  const clients = new Map();
   (_a = ctx.server.httpServer) == null ? void 0 : _a.on("upgrade", (request, socket, head) => {
     if (!request.url)
       return;

package/dist/utils.js

@@ -1,4 +1,4 @@
-export { l as deepMerge, e as ensurePackageInstalled, g as getFullName, u as getNames, f as getSuites, z as getTasks, j as getTests, h as hasFailed, x as hasTests, v as interpretOnlyMode, i as isObject, y as isWindows, p as mergeSlashes, n as noop, o as notNullish, w as partitionSuiteChildren, k as resolvePath, s as slash, t as toArray, m as toFilePath } from './index-bf29f0e6.js';
+export { l as deepMerge, e as ensurePackageInstalled, g as getFullName, v as getNames, f as getSuites, z as getTasks, j as getTests, h as hasFailed, x as hasTests, i as isObject, y as isWindows, p as mergeSlashes, n as noop, o as notNullish, w as partitionSuiteChildren, k as resolvePath, s as slash, t as toArray, m as toFilePath } from './index-090545ef.js';
 import 'url';
 import 'tty';
 import 'local-pkg';

package/dist/{vi-39f06eb7.js → vi-db2bc738.js}

@@ -1,6 +1,6 @@
-import { n as noop, i as isObject } from './index-bf29f0e6.js';
+import { n as noop, i as isObject } from './index-090545ef.js';
 import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers-c9e3b764.js';
-import { a as spyOn, f as fn, s as spies } from './jest-mock-4a754991.js';
+import { a as spyOn, f as fn, s as spies } from './jest-mock-038a01b3.js';
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
@@ -86,8 +86,8 @@ function normalizeTest(fn, timeout) {
   return withTimeout(ensureAsyncTest(fn), timeout);
 }
 
-const fnMap = /* @__PURE__ */ new WeakMap();
-const hooksMap = /* @__PURE__ */ new WeakMap();
+const fnMap = new WeakMap();
+const hooksMap = new WeakMap();
 function setFn(key, fn) {
   fnMap.set(key, fn);
 }
@@ -206,7 +206,7 @@ function equals(a, b, customTesters, strictCheck) {
 function isAsymmetric(obj) {
   return !!obj && isA("Function", obj.asymmetricMatch);
 }
-function hasAsymmetric(obj, seen = /* @__PURE__ */ new Set()) {
+function hasAsymmetric(obj, seen = new Set()) {
   if (seen.has(obj))
     return false;
   seen.add(obj);
@@ -410,7 +410,7 @@ const hasPropertyInObject = (object, key) => {
 };
 const isObjectWithKeys = (a) => isObject(a) && !(a instanceof Error) && !(a instanceof Array) && !(a instanceof Date);
 const subsetEquality = (object, subset) => {
-  const subsetEqualityWithContext = (seenReferences = /* @__PURE__ */ new WeakMap()) => (object2, subset2) => {
+  const subsetEqualityWithContext = (seenReferences = new WeakMap()) => (object2, subset2) => {
     if (!isObjectWithKeys(subset2))
       return void 0;
     return Object.keys(subset2).every((key) => {
@@ -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: {}};
@@ -797,6 +871,12 @@ const originalSetInterval = global.setInterval;
 const originalClearTimeout = global.clearTimeout;
 const originalClearInterval = global.clearInterval;
 const MAX_LOOPS = 1e4;
+var QueueTaskType;
+(function(QueueTaskType2) {
+  QueueTaskType2["Interval"] = "interval";
+  QueueTaskType2["Timeout"] = "timeout";
+  QueueTaskType2["Immediate"] = "immediate";
+})(QueueTaskType || (QueueTaskType = {}));
 const assertEvery = (assertions, message) => {
   if (assertions.some((a) => !a))
     throw new Error(message);
@@ -841,8 +921,8 @@ class FakeTimers {
         return resultBuilder(id, cb);
       };
     };
-    this._setTimeout = spyOn(global, "setTimeout").mockImplementation(spyFactory("timeout" /* Timeout */, getNodeTimeout));
-    this._setInterval = spyOn(global, "setInterval").mockImplementation(spyFactory("interval" /* Interval */, getNodeTimeout));
+    this._setTimeout = spyOn(global, "setTimeout").mockImplementation(spyFactory(QueueTaskType.Timeout, getNodeTimeout));
+    this._setInterval = spyOn(global, "setInterval").mockImplementation(spyFactory(QueueTaskType.Interval, getNodeTimeout));
     const clearTimerFactory = (spyType) => (id) => {
       if (id === void 0)
         return;
@@ -850,8 +930,8 @@ class FakeTimers {
       if (index !== -1)
         this._tasksQueue.splice(index, 1);
     };
-    this._clearTimeout = spyOn(global, "clearTimeout").mockImplementation(clearTimerFactory("timeout" /* Timeout */));
-    this._clearInterval = spyOn(global, "clearInterval").mockImplementation(clearTimerFactory("interval" /* Interval */));
+    this._clearTimeout = spyOn(global, "clearTimeout").mockImplementation(clearTimerFactory(QueueTaskType.Timeout));
+    this._clearInterval = spyOn(global, "clearInterval").mockImplementation(clearTimerFactory(QueueTaskType.Interval));
   }
   useRealTimers() {
     this._isMocked = false;
@@ -947,7 +1027,7 @@ class FakeTimers {
     this._tasksQueue.sort((t1, t2) => {
       const diff = t1.call.nestedMs - t2.call.nestedMs;
       if (diff === 0) {
-        if (t1.type === "immediate" /* Immediate */ && t2.type !== "immediate" /* Immediate */)
+        if (t1.type === QueueTaskType.Immediate && t2.type !== QueueTaskType.Immediate)
           return 1;
         return 0;
       }