vitest 0.9.4 → 0.10.0

package/dist/index.d.ts

@@ -202,6 +202,36 @@ declare class ModuleCacheMap extends Map<string, ModuleCache$1> {
     get(fsPath: string): ModuleCache$1 | undefined;
     delete(fsPath: string): boolean;
 }
+declare class ViteNodeRunner {
+    options: ViteNodeRunnerOptions;
+    root: string;
+    debug: boolean;
+    /**
+     * Holds the cache of modules
+     * Keys of the map are filepaths, or plain package names
+     */
+    moduleCache: ModuleCacheMap;
+    constructor(options: ViteNodeRunnerOptions);
+    executeFile(file: string): Promise<any>;
+    executeId(id: string): Promise<any>;
+    /** @internal */
+    cachedRequest(rawId: string, callstack: string[]): Promise<any>;
+    /** @internal */
+    directRequest(id: string, fsPath: string, _callstack: string[]): Promise<any>;
+    prepareContext(context: Record<string, any>): Record<string, any>;
+    shouldResolveId(dep: string): boolean;
+    /**
+     * Define if a module should be interop-ed
+     * This function mostly for the ability to override by subclass
+     */
+    shouldInterop(path: string, mod: any): boolean;
+    /**
+     * Import a module and interop it
+     */
+    interopedImport(path: string): Promise<any>;
+    hasNestedDefault(target: any): any;
+    private debugLog;
+}
 
 interface DepsHandlingOptions {
     external?: (string | RegExp)[];
@@ -229,11 +259,22 @@ interface FetchResult {
     map?: RawSourceMap;
 }
 declare type FetchFunction = (id: string) => Promise<FetchResult>;
+declare type ResolveIdFunction$1 = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
 interface ModuleCache$1 {
     promise?: Promise<any>;
     exports?: any;
     code?: string;
 }
+interface ViteNodeRunnerOptions {
+    root: string;
+    fetchModule: FetchFunction;
+    resolveId?: ResolveIdFunction$1;
+    base?: string;
+    moduleCache?: ModuleCacheMap;
+    interopDefault?: boolean;
+    requestStubs?: Record<string, any>;
+    debug?: boolean;
+}
 interface ViteNodeResolveId {
     external?: boolean | 'absolute' | 'relative';
     id: string;
@@ -331,6 +372,7 @@ declare class Vitest {
     closingPromise?: Promise<void>;
     isFirstRun: boolean;
     restartsCount: number;
+    runner: ViteNodeRunner;
     private _onRestartListeners;
     constructor();
     setServer(options: UserConfig, server: ViteDevServer): Promise<void>;
@@ -713,15 +755,16 @@ interface File extends Suite {
     filepath: string;
     collectDuration?: number;
 }
-interface Test extends TaskBase {
+interface Test<ExtraContext = {}> extends TaskBase {
     type: 'test';
     suite: Suite;
     result?: TaskResult;
     fails?: boolean;
+    context: TestContext & ExtraContext;
 }
 declare type Task = Test | Suite | File;
 declare type DoneCallback = (error?: any) => void;
-declare type TestFunction = (done: DoneCallback) => Awaitable<void>;
+declare type TestFunction<ExtraContext = {}> = (context: TestContext & ExtraContext) => Awaitable<void>;
 declare type ExtractEachCallbackArgs<T extends ReadonlyArray<any>> = {
     1: [T[0]];
     2: [T[0], T[1]];
@@ -736,36 +779,37 @@ declare type ExtractEachCallbackArgs<T extends ReadonlyArray<any>> = {
     fallback: Array<T extends ReadonlyArray<infer U> ? U : any>;
 }[T extends Readonly<[any]> ? 1 : T extends Readonly<[any, any]> ? 2 : T extends Readonly<[any, any, any]> ? 3 : T extends Readonly<[any, any, any, any]> ? 4 : T extends Readonly<[any, any, any, any, any]> ? 5 : T extends Readonly<[any, any, any, any, any, any]> ? 6 : T extends Readonly<[any, any, any, any, any, any, any]> ? 7 : T extends Readonly<[any, any, any, any, any, any, any, any]> ? 8 : T extends Readonly<[any, any, any, any, any, any, any, any, any]> ? 9 : T extends Readonly<[any, any, any, any, any, any, any, any, any, any]> ? 10 : 'fallback'];
 interface EachFunction {
-    <T extends any[] | [any]>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T) => void) => void;
-    <T extends ReadonlyArray<any>>(cases: ReadonlyArray<T>): (name: string, fn: (...args: ExtractEachCallbackArgs<T>) => void) => void;
-    <T>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T[]) => void) => void;
+    <T extends any[] | [any]>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T) => Awaitable<void>) => void;
+    <T extends ReadonlyArray<any>>(cases: ReadonlyArray<T>): (name: string, fn: (...args: ExtractEachCallbackArgs<T>) => Awaitable<void>) => void;
+    <T>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T[]) => Awaitable<void>) => void;
 }
-declare type TestAPI = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo' | 'fails', [
+declare type TestAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo' | 'fails', [
     name: string,
-    fn?: TestFunction,
+    fn?: TestFunction<ExtraContext>,
     timeout?: number
 ], void> & {
     each: EachFunction;
 };
-declare type SuiteAPI = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo', [
+declare type SuiteAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo', [
     name: string,
     factory?: SuiteFactory
-], SuiteCollector> & {
+], SuiteCollector<ExtraContext>> & {
     each: EachFunction;
 };
-declare type HookListener<T extends any[]> = (...args: T) => Awaitable<void>;
+declare type HookListener<T extends any[], Return = void> = (...args: T) => Awaitable<Return | void>;
 interface SuiteHooks {
-    beforeAll: HookListener<[Suite]>[];
+    beforeAll: HookListener<[Suite], () => Awaitable<void>>[];
     afterAll: HookListener<[Suite]>[];
-    beforeEach: HookListener<[Test, Suite]>[];
-    afterEach: HookListener<[Test, Suite]>[];
+    beforeEach: HookListener<[TestContext, Suite], () => Awaitable<void>>[];
+    afterEach: HookListener<[TestContext, Suite]>[];
 }
-interface SuiteCollector {
+declare type HookCleanupCallback = (() => Awaitable<void>) | void;
+interface SuiteCollector<ExtraContext = {}> {
     readonly name: string;
     readonly mode: RunMode;
     type: 'collector';
-    test: TestAPI;
-    tasks: (Suite | Test | SuiteCollector)[];
+    test: TestAPI<ExtraContext>;
+    tasks: (Suite | Test | SuiteCollector<ExtraContext>)[];
     collect: (file?: File) => Promise<Suite>;
     clear: () => void;
     on: <T extends keyof SuiteHooks>(name: T, ...fn: SuiteHooks[T]) => void;
@@ -775,6 +819,20 @@ interface RuntimeContext {
     tasks: (SuiteCollector | Test)[];
     currentSuite: SuiteCollector | null;
 }
+interface TestContext {
+    /**
+     * @deprecated Use promise instead
+     */
+    (error?: any): void;
+    /**
+     * Metadata of the current test
+     */
+    meta: Readonly<Test>;
+    /**
+     * A expect instance bound to the test
+     */
+    expect: Vi.ExpectStatic;
+}
 
 interface Reporter {
     onInit?(ctx: Vitest): void;
@@ -939,9 +997,10 @@ interface InlineConfig {
      */
     root?: string;
     /**
-     * Custom reporter for output
+     * Custom reporter for output. Can contain one or more built-in report names, reporter instances,
+     * and/or paths to custom reporters
      */
-    reporters?: Arrayable<BuiltinReporters | Reporter>;
+    reporters?: Arrayable<BuiltinReporters | Reporter | string>;
     /**
      * diff output length
      */
@@ -1182,16 +1241,21 @@ interface WorkerGlobalState {
     mockMap: MockMap;
 }
 
-declare const suite: SuiteAPI;
-declare const test: TestAPI;
-declare const describe: SuiteAPI;
-declare const it: TestAPI;
+declare const suite: SuiteAPI<{}>;
+declare const test: TestAPI<{}>;
+declare const describe: SuiteAPI<{}>;
+declare const it: TestAPI<{}>;
 
 declare const beforeAll: (fn: SuiteHooks['beforeAll'][0], timeout?: number | undefined) => void;
 declare const afterAll: (fn: SuiteHooks['afterAll'][0], timeout?: number | undefined) => void;
 declare const beforeEach: (fn: SuiteHooks['beforeEach'][0], timeout?: number | undefined) => void;
 declare const afterEach: (fn: SuiteHooks['afterEach'][0], timeout?: number | undefined) => void;
 
+/**
+ * A simple wrapper for converting callback style to promise
+ */
+declare function withCallback(fn: (done: DoneCallback) => void): Promise<void>;
+
 /**
  * This utils allows computational intensive tasks to only be ran once
  * across test reruns to improve the watch mode performance.
@@ -1211,8 +1275,6 @@ declare function runOnce<T>(fn: (() => T), key?: string): T;
  */
 declare function isFirstRun(): boolean;
 
-declare const expect: Vi.ExpectStatic;
-
 interface MockResultReturn<T> {
     type: 'return';
     value: T;
@@ -1293,6 +1355,9 @@ declare function spyOn<T, M extends (Methods<Required<T>> | Classes<Required<T>>
 declare function fn<TArgs extends any[] = any[], R = any>(): SpyInstanceFn<TArgs, R>;
 declare function fn<TArgs extends any[] = any[], R = any>(implementation: (...args: TArgs) => R): SpyInstanceFn<TArgs, R>;
 
+declare function createExpect(test?: Test): Vi.ExpectStatic;
+declare const expect: Vi.ExpectStatic;
+
 declare class VitestUtils {
     private _timers;
     private _mockedDate;
@@ -1513,4 +1578,4 @@ declare global {
     }
 }
 
-export { ApiConfig, ArgumentsType$1 as ArgumentsType, Arrayable, Awaitable, BuiltinEnvironment, C8Options, Constructable, CoverageReporter, DeepMerge, DoneCallback, EnhancedSpy, Environment, EnvironmentOptions, EnvironmentReturn, ErrorWithDiff, File, HookListener, InlineConfig, JSDOMOptions, MergeInsertions, MockedFunction, MockedObject, ModuleCache, ModuleGraphData, MutableArray, Nullable, ParsedStack, Position, Reporter, ResolveIdFunction, ResolvedC8Options, ResolvedConfig, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, SpyContext, SpyInstance, SpyInstanceFn, Suite, SuiteAPI, SuiteCollector, SuiteFactory, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestAPI, TestFunction, TransformResultWithSource, UncheckedSnapshot, UserConfig, UserConsoleLog, Vitest, WebSocketEvents, WebSocketHandlers, WorkerContext, WorkerGlobalState, WorkerRPC, afterAll, afterEach, beforeAll, beforeEach, describe, expect, getRunningMode, isFirstRun, isWatchMode, it, runOnce, suite, test, vi, vitest };
+export { ApiConfig, ArgumentsType$1 as ArgumentsType, Arrayable, Awaitable, BuiltinEnvironment, C8Options, Constructable, CoverageReporter, DeepMerge, DoneCallback, EnhancedSpy, Environment, EnvironmentOptions, EnvironmentReturn, ErrorWithDiff, File, HookCleanupCallback, HookListener, InlineConfig, JSDOMOptions, MergeInsertions, MockedFunction, MockedObject, ModuleCache, ModuleGraphData, MutableArray, Nullable, ParsedStack, Position, Reporter, ResolveIdFunction, ResolvedC8Options, ResolvedConfig, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, SpyContext, SpyInstance, SpyInstanceFn, Suite, SuiteAPI, SuiteCollector, SuiteFactory, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestAPI, TestContext, TestFunction, TransformResultWithSource, UncheckedSnapshot, UserConfig, UserConsoleLog, Vitest, WebSocketEvents, WebSocketHandlers, WorkerContext, WorkerGlobalState, WorkerRPC, afterAll, afterEach, beforeAll, beforeEach, createExpect, describe, expect, getRunningMode, isFirstRun, isWatchMode, it, runOnce, suite, test, vi, vitest, withCallback };

package/dist/index.js

@@ -1,13 +1,13 @@
-export { p as afterAll, u as afterEach, o as beforeAll, q as beforeEach, k as describe, w as expect, y as getRunningMode, n as isFirstRun, z as isWatchMode, l as it, m as runOnce, j as suite, t as test, v as vi, x as vitest } from './chunk-runtime-chain.701cffd8.js';
+export { c as afterAll, f as afterEach, b as beforeAll, e as beforeEach, g as createExpect, d as describe, h as expect, k as getRunningMode, a as isFirstRun, l as isWatchMode, i as it, r as runOnce, s as suite, t as test, j as vi, v as vitest, w as withCallback } from './chunk-runtime-chain.f863f182.js';
 export { assert, default as chai, should } from 'chai';
-import 'util';
-import './chunk-utils-global.a3293dce.js';
-import 'path';
+import './vendor-_commonjsHelpers.addc3445.js';
+import './chunk-runtime-rpc.8f648236.js';
+import './chunk-utils-global.37a7c822.js';
 import 'tty';
 import 'local-pkg';
-import './chunk-utils-timers.b26e7c5c.js';
-import './vendor-_commonjsHelpers.34b404ce.js';
-import './chunk-runtime-rpc.c47f2233.js';
+import 'path';
 import 'fs';
-import './spy.js';
+import './chunk-utils-timers.12bc05d1.js';
+import './chunk-integrations-spy.f036df6f.js';
 import 'tinyspy';
+import 'util';

package/dist/node.d.ts

@@ -522,19 +522,34 @@ interface File extends Suite {
     filepath: string;
     collectDuration?: number;
 }
-interface Test extends TaskBase {
+interface Test<ExtraContext = {}> extends TaskBase {
     type: 'test';
     suite: Suite;
     result?: TaskResult;
     fails?: boolean;
+    context: TestContext & ExtraContext;
 }
 declare type Task = Test | Suite | File;
-declare type HookListener<T extends any[]> = (...args: T) => Awaitable<void>;
+declare type HookListener<T extends any[], Return = void> = (...args: T) => Awaitable<Return | void>;
 interface SuiteHooks {
-    beforeAll: HookListener<[Suite]>[];
+    beforeAll: HookListener<[Suite], () => Awaitable<void>>[];
     afterAll: HookListener<[Suite]>[];
-    beforeEach: HookListener<[Test, Suite]>[];
-    afterEach: HookListener<[Test, Suite]>[];
+    beforeEach: HookListener<[TestContext, Suite], () => Awaitable<void>>[];
+    afterEach: HookListener<[TestContext, Suite]>[];
+}
+interface TestContext {
+    /**
+     * @deprecated Use promise instead
+     */
+    (error?: any): void;
+    /**
+     * Metadata of the current test
+     */
+    meta: Readonly<Test>;
+    /**
+     * A expect instance bound to the test
+     */
+    expect: Vi.ExpectStatic;
 }
 
 interface Reporter {
@@ -691,9 +706,10 @@ interface InlineConfig {
      */
     root?: string;
     /**
-     * Custom reporter for output
+     * Custom reporter for output. Can contain one or more built-in report names, reporter instances,
+     * and/or paths to custom reporters
      */
-    reporters?: Arrayable<BuiltinReporters | Reporter>;
+    reporters?: Arrayable<BuiltinReporters | Reporter | string>;
     /**
      * diff output length
      */
@@ -942,6 +958,7 @@ declare class Vitest {
     closingPromise?: Promise<void>;
     isFirstRun: boolean;
     restartsCount: number;
+    runner: ViteNodeRunner;
     private _onRestartListeners;
     constructor();
     setServer(options: UserConfig, server: ViteDevServer): Promise<void>;

package/dist/node.js

@@ -1,11 +1,11 @@
-export { V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-vite-node-externalize.1c19fc5e.js';
-export { V as VitestRunner } from './chunk-runtime-mocker.e802beae.js';
+export { V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-vite-node-externalize.5c678054.js';
+export { V as VitestRunner } from './chunk-runtime-mocker.111ac858.js';
 import 'buffer';
 import 'path';
 import 'child_process';
 import 'process';
-import './vendor-index.bd255bc8.js';
-import './vendor-_commonjsHelpers.34b404ce.js';
+import './vendor-index.40be925a.js';
+import './vendor-_commonjsHelpers.addc3445.js';
 import 'fs';
 import 'assert';
 import 'events';
@@ -13,19 +13,19 @@ import 'stream';
 import 'util';
 import 'url';
 import 'os';
-import './chunk-utils-global.a3293dce.js';
+import './chunk-utils-global.37a7c822.js';
 import 'tty';
 import 'local-pkg';
 import 'vite';
-import './chunk-constants.c8f1d38c.js';
+import './chunk-constants.d540b1d1.js';
 import 'readline';
-import './chunk-vite-node-utils.b4debb0b.js';
+import './chunk-vite-node-utils.33447cc0.js';
 import 'module';
 import 'vm';
-import './chunk-defaults.43e746f3.js';
-import 'perf_hooks';
-import './chunk-utils-timers.b26e7c5c.js';
+import './chunk-defaults.04d5d90b.js';
 import 'worker_threads';
 import 'tinypool';
+import 'perf_hooks';
+import './chunk-utils-timers.12bc05d1.js';
 import './chunk-magic-string.d5e0e473.js';
-import './vendor-index.13468339.js';
+import './vendor-index.405e58ef.js';

package/dist/spy.js

@@ -1,102 +1,2 @@
-import * as tinyspy from 'tinyspy';
-
-const spies = /* @__PURE__ */ new Set();
-function isMockFunction(fn2) {
-  return typeof fn2 === "function" && "_isMockFunction" in fn2 && fn2._isMockFunction;
-}
-function spyOn(obj, method, accessType) {
-  const dictionary = {
-    get: "getter",
-    set: "setter"
-  };
-  const objMethod = accessType ? { [dictionary[accessType]]: method } : method;
-  const stub = tinyspy.spyOn(obj, objMethod);
-  return enhanceSpy(stub);
-}
-let callOrder = 0;
-function enhanceSpy(spy) {
-  const stub = spy;
-  let implementation;
-  let instances = [];
-  let invocations = [];
-  const mockContext = {
-    get calls() {
-      return stub.calls;
-    },
-    get instances() {
-      return instances;
-    },
-    get invocationCallOrder() {
-      return invocations;
-    },
-    get results() {
-      return stub.results.map(([callType, value]) => {
-        const type = callType === "error" ? "throw" : "return";
-        return { type, value };
-      });
-    },
-    get lastCall() {
-      return stub.calls.at(-1);
-    }
-  };
-  let onceImplementations = [];
-  let name = stub.name;
-  stub.getMockName = () => name || "vi.fn()";
-  stub.mockName = (n) => {
-    name = n;
-    return stub;
-  };
-  stub.mockClear = () => {
-    stub.reset();
-    instances = [];
-    invocations = [];
-    return stub;
-  };
-  stub.mockReset = () => {
-    stub.mockClear();
-    implementation = () => void 0;
-    onceImplementations = [];
-    return stub;
-  };
-  stub.mockRestore = () => {
-    stub.mockReset();
-    implementation = void 0;
-    return stub;
-  };
-  stub.getMockImplementation = () => implementation;
-  stub.mockImplementation = (fn2) => {
-    implementation = fn2;
-    return stub;
-  };
-  stub.mockImplementationOnce = (fn2) => {
-    onceImplementations.push(fn2);
-    return stub;
-  };
-  stub.mockReturnThis = () => stub.mockImplementation(function() {
-    return this;
-  });
-  stub.mockReturnValue = (val) => stub.mockImplementation(() => val);
-  stub.mockReturnValueOnce = (val) => stub.mockImplementationOnce(() => val);
-  stub.mockResolvedValue = (val) => stub.mockImplementation(() => Promise.resolve(val));
-  stub.mockResolvedValueOnce = (val) => stub.mockImplementationOnce(() => Promise.resolve(val));
-  stub.mockRejectedValue = (val) => stub.mockImplementation(() => Promise.reject(val));
-  stub.mockRejectedValueOnce = (val) => stub.mockImplementationOnce(() => Promise.reject(val));
-  Object.defineProperty(stub, "mock", {
-    get: () => mockContext
-  });
-  stub.willCall(function(...args) {
-    instances.push(this);
-    invocations.push(++callOrder);
-    const impl = onceImplementations.shift() || implementation || stub.getOriginal() || (() => {
-    });
-    return impl.apply(this, args);
-  });
-  spies.add(stub);
-  return stub;
-}
-function fn(implementation) {
-  return enhanceSpy(tinyspy.spyOn({ fn: implementation || (() => {
-  }) }, "fn"));
-}
-
-export { fn, isMockFunction, spies, spyOn };
+export { f as fn, i as isMockFunction, a as spies, s as spyOn } from './chunk-integrations-spy.f036df6f.js';
+import 'tinyspy';

package/dist/vendor-_commonjsHelpers.addc3445.js

@@ -0,0 +1,3 @@
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+export { commonjsGlobal as c };