vitest 0.18.1 → 0.19.0

package/dist/index.d.ts

@@ -1,8 +1,10 @@
-import { ViteDevServer, TransformResult, CommonServerOptions } from 'vite';
+import { ViteDevServer, TransformResult, CommonServerOptions, AliasOptions } from 'vite';
 import { Stats } from 'fs';
 import { SpyImpl } from 'tinyspy';
 import { MessagePort } from 'worker_threads';
-export { assert, default as chai, should } from 'chai';
+import * as chai from 'chai';
+export { chai };
+export { assert, should } from 'chai';
 
 /**
  * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
@@ -374,15 +376,18 @@ interface WorkerPool {
 
 declare class StateManager {
     filesMap: Map<string, File>;
+    pathsSet: Set<string>;
     idMap: Map<string, Task>;
     taskFileMap: WeakMap<Task, File>;
     errorsSet: Set<unknown>;
     catchError(err: unknown, type: string): void;
     clearErrors(): void;
     getUnhandledErrors(): unknown[];
+    getPaths(): string[];
     getFiles(keys?: string[]): File[];
     getFilepaths(): string[];
     getFailedFilepaths(): string[];
+    collectPaths(paths?: string[]): void;
     collectFiles(files?: File[]): void;
     clearFiles(paths?: string[]): void;
     updateId(task: Task): void;
@@ -528,7 +533,7 @@ declare abstract class BaseReporter implements Reporter {
     start: number;
     end: number;
     watchFilters?: string[];
-    isTTY: boolean;
+    isTTY: false;
     ctx: Vitest;
     private _filesInWatchMode;
     private _lastRunTimeout;
@@ -584,6 +589,10 @@ declare class DotReporter extends BaseReporter {
     onUserConsoleLog(log: UserConsoleLog): void;
 }
 
+interface Callsite {
+    line: number;
+    column: number;
+}
 declare class JsonReporter implements Reporter {
     start: number;
     ctx: Vitest;
@@ -596,6 +605,7 @@ declare class JsonReporter implements Reporter {
      * @param report
      */
     writeReport(report: string): Promise<void>;
+    protected getFailureLocation(test: Test): Callsite | undefined;
 }
 
 declare class VerboseReporter extends DefaultReporter {
@@ -970,6 +980,7 @@ interface TestContext {
 
 interface Reporter {
     onInit?(ctx: Vitest): void;
+    onPathsCollected?: (paths?: string[]) => Awaitable<void>;
     onCollected?: (files?: File[]) => Awaitable<void>;
     onFinished?: (files?: File[], errors?: unknown[]) => Awaitable<void>;
     onTaskUpdate?: (packs: TaskResultPack[]) => Awaitable<void>;
@@ -1180,6 +1191,12 @@ interface InlineConfig {
      * @default 10000
      */
     hookTimeout?: number;
+    /**
+     * Default timeout to wait for close when Vitest shuts down, in milliseconds
+     *
+     * @default 1000
+     */
+    teardownTimeout?: number;
     /**
      * Silent mode
      *
@@ -1248,6 +1265,11 @@ interface InlineConfig {
      * @internal WIP
      */
     ui?: boolean;
+    /**
+     * Use in browser environment
+     * @experimental
+     */
+    browser?: boolean;
     /**
      * Open UI automatically.
      *
@@ -1359,6 +1381,12 @@ interface InlineConfig {
          */
         seed?: number;
     };
+    /**
+     * Specifies an `Object`, or an `Array` of `Object`,
+     * which defines aliases used to replace values in `import` or `require` statements.
+     * Will be merged with the default aliases inside `resolve.alias`.
+     */
+    alias?: AliasOptions;
 }
 interface UserConfig extends InlineConfig {
     /**
@@ -1710,6 +1738,7 @@ interface WorkerRPC {
     getSourceMap: (id: string, force?: boolean) => Promise<RawSourceMap | undefined>;
     onFinished: (files: File[], errors?: unknown[]) => void;
     onWorkerExit: (code?: number) => void;
+    onPathsCollected: (paths: string[]) => void;
     onUserConsoleLog: (log: UserConsoleLog) => void;
     onUnhandledRejection: (err: unknown) => void;
     onCollected: (files: File[]) => void;
@@ -1724,6 +1753,7 @@ interface WorkerGlobalState {
     current?: Test;
     filepath?: string;
     moduleCache: ModuleCacheMap;
+    browserHashMap?: Map<string, string>;
     mockMap: MockMap;
 }
 
@@ -1959,7 +1989,12 @@ interface TransformResultWithSource extends TransformResult {
     source?: string;
 }
 interface WebSocketHandlers {
+    onWatcherStart: () => Promise<void>;
+    onFinished(files?: File[]): Promise<void>;
+    onCollected(files?: File[]): Promise<void>;
+    onTaskUpdate(packs: TaskResultPack[]): void;
     getFiles(): File[];
+    getPaths(): string[];
     getConfig(): ResolvedConfig;
     getModuleGraph(id: string): Promise<ModuleGraphData>;
     getTransformResult(id: string): Promise<TransformResultWithSource | undefined>;
@@ -1968,7 +2003,7 @@ interface WebSocketHandlers {
     rerun(files: string[]): Promise<void>;
     updateSnapshot(file?: File): Promise<void>;
 }
-interface WebSocketEvents extends Pick<Reporter, 'onCollected' | 'onFinished' | 'onTaskUpdate' | 'onUserConsoleLog'> {
+interface WebSocketEvents extends Pick<Reporter, 'onCollected' | 'onFinished' | 'onTaskUpdate' | 'onUserConsoleLog' | 'onPathsCollected'> {
 }
 
 export { ApiConfig, ArgumentsType$1 as ArgumentsType, Arrayable, Awaitable, BuiltinEnvironment, C8Options, Constructable$1 as Constructable, CoverageReporter, DeepMerge, DoneCallback, EnhancedSpy, Environment, EnvironmentOptions, EnvironmentReturn, ErrorWithDiff, File, HookCleanupCallback, HookListener, InlineConfig, JSDOMOptions, MergeInsertions, Mock, MockContext, MockInstance, Mocked, MockedClass, MockedFunction, MockedObject, ModuleCache, ModuleGraphData, MutableArray, Nullable, ParsedStack, Position, Reporter, ResolveIdFunction, ResolvedC8Options, ResolvedConfig, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, SpyInstance, 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, globalExpect as expect, getRunningMode, isFirstRun, isWatchMode, it, runOnce, suite, test, vi, vitest, withCallback };

package/dist/index.mjs

@@ -1,13 +1,16 @@
-export { p as afterAll, u as afterEach, o as beforeAll, q as beforeEach, x as createExpect, k as describe, y as expect, A as getRunningMode, n as isFirstRun, B as isWatchMode, l as it, m as runOnce, j as suite, t as test, v as vi, z as vitest, w as withCallback } from './chunk-runtime-chain.b60d57da.mjs';
-export { assert, default as chai, should } from 'chai';
+export { c as createExpect, d as describe, b as expect, i as it, s as suite, t as test } from './chunk-runtime-chain.1e1aabb3.mjs';
+export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, h as getRunningMode, f as isFirstRun, j as isWatchMode, e as runOnce, v as vi, g as vitest, w as withCallback } from './chunk-runtime-hooks.db398170.mjs';
+import * as chai from 'chai';
+export { chai };
+export { assert, should } from 'chai';
 import 'util';
-import './chunk-utils-global.0a7416cf.mjs';
+import './chunk-utils-global.2aa95025.mjs';
 import 'path';
 import 'tty';
 import 'local-pkg';
 import './vendor-_commonjsHelpers.4da45ef5.mjs';
-import './chunk-runtime-rpc.9d1f4c48.mjs';
+import './chunk-runtime-rpc.45d8ee19.mjs';
 import 'fs';
-import './chunk-utils-source-map.c03f8bc4.mjs';
+import './chunk-utils-source-map.8b066ce2.mjs';
 import './spy.mjs';
 import 'tinyspy';

package/dist/node.d.ts

@@ -1,4 +1,4 @@
-import { ViteDevServer, TransformResult, CommonServerOptions, UserConfig as UserConfig$1, Plugin as Plugin$1 } from 'vite';
+import { ViteDevServer, TransformResult, AliasOptions, CommonServerOptions, UserConfig as UserConfig$1, Plugin as Plugin$1 } from 'vite';
 import { Stats } from 'fs';
 
 interface UpdatePayload {
@@ -357,7 +357,7 @@ declare abstract class BaseReporter implements Reporter {
     start: number;
     end: number;
     watchFilters?: string[];
-    isTTY: boolean;
+    isTTY: false;
     ctx: Vitest;
     private _filesInWatchMode;
     private _lastRunTimeout;
@@ -439,6 +439,10 @@ declare class DotReporter extends BaseReporter {
     onUserConsoleLog(log: UserConsoleLog): void;
 }
 
+interface Callsite {
+    line: number;
+    column: number;
+}
 declare class JsonReporter implements Reporter {
     start: number;
     ctx: Vitest;
@@ -451,6 +455,7 @@ declare class JsonReporter implements Reporter {
      * @param report
      */
     writeReport(report: string): Promise<void>;
+    protected getFailureLocation(test: Test): Callsite | undefined;
 }
 
 declare class VerboseReporter extends DefaultReporter {
@@ -750,6 +755,7 @@ interface TestContext {
 
 interface Reporter {
     onInit?(ctx: Vitest): void;
+    onPathsCollected?: (paths?: string[]) => Awaitable<void>;
     onCollected?: (files?: File[]) => Awaitable<void>;
     onFinished?: (files?: File[], errors?: unknown[]) => Awaitable<void>;
     onTaskUpdate?: (packs: TaskResultPack[]) => Awaitable<void>;
@@ -959,6 +965,12 @@ interface InlineConfig {
      * @default 10000
      */
     hookTimeout?: number;
+    /**
+     * Default timeout to wait for close when Vitest shuts down, in milliseconds
+     *
+     * @default 1000
+     */
+    teardownTimeout?: number;
     /**
      * Silent mode
      *
@@ -1027,6 +1039,11 @@ interface InlineConfig {
      * @internal WIP
      */
     ui?: boolean;
+    /**
+     * Use in browser environment
+     * @experimental
+     */
+    browser?: boolean;
     /**
      * Open UI automatically.
      *
@@ -1138,6 +1155,12 @@ interface InlineConfig {
          */
         seed?: number;
     };
+    /**
+     * Specifies an `Object`, or an `Array` of `Object`,
+     * which defines aliases used to replace values in `import` or `require` statements.
+     * Will be merged with the default aliases inside `resolve.alias`.
+     */
+    alias?: AliasOptions;
 }
 interface UserConfig extends InlineConfig {
     /**
@@ -1482,15 +1505,18 @@ interface WorkerPool {
 
 declare class StateManager {
     filesMap: Map<string, File>;
+    pathsSet: Set<string>;
     idMap: Map<string, Task>;
     taskFileMap: WeakMap<Task, File>;
     errorsSet: Set<unknown>;
     catchError(err: unknown, type: string): void;
     clearErrors(): void;
     getUnhandledErrors(): unknown[];
+    getPaths(): string[];
     getFiles(keys?: string[]): File[];
     getFilepaths(): string[];
     getFailedFilepaths(): string[];
+    collectPaths(paths?: string[]): void;
     collectFiles(files?: File[]): void;
     clearFiles(paths?: string[]): void;
     updateId(task: Task): void;

package/dist/node.mjs

@@ -1,33 +1,31 @@
-export { B as BaseSequencer, V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-vite-node-externalize.6956d2d9.mjs';
-export { V as VitestRunner } from './chunk-runtime-mocker.1d853e3a.mjs';
-import './chunk-env-node.bbba78e5.mjs';
+export { B as BaseSequencer, V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-vite-node-externalize.a2813ad7.mjs';
+export { V as VitestRunner } from './chunk-runtime-mocker.dfdfd57b.mjs';
+import './chunk-utils-global.2aa95025.mjs';
+import 'path';
+import 'tty';
 import 'local-pkg';
+import './chunk-defaults.408a0cfe.mjs';
 import 'fs';
 import 'module';
 import 'url';
-import './chunk-utils-global.0a7416cf.mjs';
-import 'path';
-import 'tty';
 import 'vite';
 import 'process';
-import './chunk-constants.d4406290.mjs';
+import './chunk-constants.38b43a44.mjs';
 import 'os';
 import 'util';
 import 'stream';
 import 'events';
 import './vendor-_commonjsHelpers.4da45ef5.mjs';
-import './chunk-vite-node-utils.8077cd3c.mjs';
+import './chunk-vite-node-utils.ad73f2ab.mjs';
 import 'vm';
 import 'assert';
 import 'debug';
 import 'worker_threads';
 import 'tinypool';
 import 'perf_hooks';
-import './chunk-utils-source-map.c03f8bc4.mjs';
+import './chunk-utils-source-map.8b066ce2.mjs';
 import 'crypto';
-import 'buffer';
-import 'child_process';
-import './vendor-index.4bf9c627.mjs';
+import './vendor-index.61438b77.mjs';
 import './chunk-magic-string.efe26975.mjs';
 import 'readline';
 import './vendor-index.de788b6a.mjs';

package/dist/suite.mjs

@@ -0,0 +1,13 @@
+import 'util';
+import './chunk-utils-global.2aa95025.mjs';
+export { e as clearCollectorContext, o as createSuiteHooks, f as defaultSuite, d as describe, g as getCurrentSuite, i as it, s as suite, t as test } from './chunk-runtime-chain.1e1aabb3.mjs';
+import 'path';
+import 'tty';
+import 'local-pkg';
+import 'chai';
+import './vendor-_commonjsHelpers.4da45ef5.mjs';
+import './chunk-runtime-rpc.45d8ee19.mjs';
+import 'fs';
+import './chunk-utils-source-map.8b066ce2.mjs';
+import './spy.mjs';
+import 'tinyspy';

package/dist/vendor-index.61438b77.mjs

@@ -0,0 +1,335 @@
+import { c as commonjsGlobal } from './vendor-_commonjsHelpers.4da45ef5.mjs';
+import assert$1 from 'assert';
+import require$$2 from 'events';
+
+var onetime$1 = {exports: {}};
+
+var mimicFn$2 = {exports: {}};
+
+const mimicFn$1 = (to, from) => {
+	for (const prop of Reflect.ownKeys(from)) {
+		Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
+	}
+
+	return to;
+};
+
+mimicFn$2.exports = mimicFn$1;
+// TODO: Remove this for the next major release
+mimicFn$2.exports.default = mimicFn$1;
+
+const mimicFn = mimicFn$2.exports;
+
+const calledFunctions = new WeakMap();
+
+const onetime = (function_, options = {}) => {
+	if (typeof function_ !== 'function') {
+		throw new TypeError('Expected a function');
+	}
+
+	let returnValue;
+	let callCount = 0;
+	const functionName = function_.displayName || function_.name || '<anonymous>';
+
+	const onetime = function (...arguments_) {
+		calledFunctions.set(onetime, ++callCount);
+
+		if (callCount === 1) {
+			returnValue = function_.apply(this, arguments_);
+			function_ = null;
+		} else if (options.throw === true) {
+			throw new Error(`Function \`${functionName}\` can only be called once`);
+		}
+
+		return returnValue;
+	};
+
+	mimicFn(onetime, function_);
+	calledFunctions.set(onetime, callCount);
+
+	return onetime;
+};
+
+onetime$1.exports = onetime;
+// TODO: Remove this for the next major release
+onetime$1.exports.default = onetime;
+
+onetime$1.exports.callCount = function_ => {
+	if (!calledFunctions.has(function_)) {
+		throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
+	}
+
+	return calledFunctions.get(function_);
+};
+
+var signalExit = {exports: {}};
+
+var signals$1 = {exports: {}};
+
+var hasRequiredSignals;
+
+function requireSignals () {
+	if (hasRequiredSignals) return signals$1.exports;
+	hasRequiredSignals = 1;
+	(function (module) {
+		// This is not the set of all possible signals.
+		//
+		// It IS, however, the set of all signals that trigger
+		// an exit on either Linux or BSD systems.  Linux is a
+		// superset of the signal names supported on BSD, and
+		// the unknown signals just fail to register, so we can
+		// catch that easily enough.
+		//
+		// Don't bother with SIGKILL.  It's uncatchable, which
+		// means that we can't fire any callbacks anyway.
+		//
+		// If a user does happen to register a handler on a non-
+		// fatal signal like SIGWINCH or something, and then
+		// exit, it'll end up firing `process.emit('exit')`, so
+		// the handler will be fired anyway.
+		//
+		// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
+		// artificially, inherently leave the process in a
+		// state from which it is not safe to try and enter JS
+		// listeners.
+		module.exports = [
+		  'SIGABRT',
+		  'SIGALRM',
+		  'SIGHUP',
+		  'SIGINT',
+		  'SIGTERM'
+		];
+
+		if (process.platform !== 'win32') {
+		  module.exports.push(
+		    'SIGVTALRM',
+		    'SIGXCPU',
+		    'SIGXFSZ',
+		    'SIGUSR2',
+		    'SIGTRAP',
+		    'SIGSYS',
+		    'SIGQUIT',
+		    'SIGIOT'
+		    // should detect profiler and enable/disable accordingly.
+		    // see #21
+		    // 'SIGPROF'
+		  );
+		}
+
+		if (process.platform === 'linux') {
+		  module.exports.push(
+		    'SIGIO',
+		    'SIGPOLL',
+		    'SIGPWR',
+		    'SIGSTKFLT',
+		    'SIGUNUSED'
+		  );
+		}
+} (signals$1));
+	return signals$1.exports;
+}
+
+// Note: since nyc uses this module to output coverage, any lines
+// that are in the direct sync flow of nyc's outputCoverage are
+// ignored, since we can never get coverage for them.
+// grab a reference to node's real process object right away
+var process$1 = commonjsGlobal.process;
+
+const processOk = function (process) {
+  return process &&
+    typeof process === 'object' &&
+    typeof process.removeListener === 'function' &&
+    typeof process.emit === 'function' &&
+    typeof process.reallyExit === 'function' &&
+    typeof process.listeners === 'function' &&
+    typeof process.kill === 'function' &&
+    typeof process.pid === 'number' &&
+    typeof process.on === 'function'
+};
+
+// some kind of non-node environment, just no-op
+/* istanbul ignore if */
+if (!processOk(process$1)) {
+  signalExit.exports = function () {
+    return function () {}
+  };
+} else {
+  var assert = assert$1;
+  var signals = requireSignals();
+  var isWin = /^win/i.test(process$1.platform);
+
+  var EE = require$$2;
+  /* istanbul ignore if */
+  if (typeof EE !== 'function') {
+    EE = EE.EventEmitter;
+  }
+
+  var emitter;
+  if (process$1.__signal_exit_emitter__) {
+    emitter = process$1.__signal_exit_emitter__;
+  } else {
+    emitter = process$1.__signal_exit_emitter__ = new EE();
+    emitter.count = 0;
+    emitter.emitted = {};
+  }
+
+  // Because this emitter is a global, we have to check to see if a
+  // previous version of this library failed to enable infinite listeners.
+  // I know what you're about to say.  But literally everything about
+  // signal-exit is a compromise with evil.  Get used to it.
+  if (!emitter.infinite) {
+    emitter.setMaxListeners(Infinity);
+    emitter.infinite = true;
+  }
+
+  signalExit.exports = function (cb, opts) {
+    /* istanbul ignore if */
+    if (!processOk(commonjsGlobal.process)) {
+      return function () {}
+    }
+    assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler');
+
+    if (loaded === false) {
+      load();
+    }
+
+    var ev = 'exit';
+    if (opts && opts.alwaysLast) {
+      ev = 'afterexit';
+    }
+
+    var remove = function () {
+      emitter.removeListener(ev, cb);
+      if (emitter.listeners('exit').length === 0 &&
+          emitter.listeners('afterexit').length === 0) {
+        unload();
+      }
+    };
+    emitter.on(ev, cb);
+
+    return remove
+  };
+
+  var unload = function unload () {
+    if (!loaded || !processOk(commonjsGlobal.process)) {
+      return
+    }
+    loaded = false;
+
+    signals.forEach(function (sig) {
+      try {
+        process$1.removeListener(sig, sigListeners[sig]);
+      } catch (er) {}
+    });
+    process$1.emit = originalProcessEmit;
+    process$1.reallyExit = originalProcessReallyExit;
+    emitter.count -= 1;
+  };
+  signalExit.exports.unload = unload;
+
+  var emit = function emit (event, code, signal) {
+    /* istanbul ignore if */
+    if (emitter.emitted[event]) {
+      return
+    }
+    emitter.emitted[event] = true;
+    emitter.emit(event, code, signal);
+  };
+
+  // { <signal>: <listener fn>, ... }
+  var sigListeners = {};
+  signals.forEach(function (sig) {
+    sigListeners[sig] = function listener () {
+      /* istanbul ignore if */
+      if (!processOk(commonjsGlobal.process)) {
+        return
+      }
+      // If there are no other listeners, an exit is coming!
+      // Simplest way: remove us and then re-send the signal.
+      // We know that this will kill the process, so we can
+      // safely emit now.
+      var listeners = process$1.listeners(sig);
+      if (listeners.length === emitter.count) {
+        unload();
+        emit('exit', null, sig);
+        /* istanbul ignore next */
+        emit('afterexit', null, sig);
+        /* istanbul ignore next */
+        if (isWin && sig === 'SIGHUP') {
+          // "SIGHUP" throws an `ENOSYS` error on Windows,
+          // so use a supported signal instead
+          sig = 'SIGINT';
+        }
+        /* istanbul ignore next */
+        process$1.kill(process$1.pid, sig);
+      }
+    };
+  });
+
+  signalExit.exports.signals = function () {
+    return signals
+  };
+
+  var loaded = false;
+
+  var load = function load () {
+    if (loaded || !processOk(commonjsGlobal.process)) {
+      return
+    }
+    loaded = true;
+
+    // This is the number of onSignalExit's that are in play.
+    // It's important so that we can count the correct number of
+    // listeners on signals, and don't wait for the other one to
+    // handle it instead of us.
+    emitter.count += 1;
+
+    signals = signals.filter(function (sig) {
+      try {
+        process$1.on(sig, sigListeners[sig]);
+        return true
+      } catch (er) {
+        return false
+      }
+    });
+
+    process$1.emit = processEmit;
+    process$1.reallyExit = processReallyExit;
+  };
+  signalExit.exports.load = load;
+
+  var originalProcessReallyExit = process$1.reallyExit;
+  var processReallyExit = function processReallyExit (code) {
+    /* istanbul ignore if */
+    if (!processOk(commonjsGlobal.process)) {
+      return
+    }
+    process$1.exitCode = code || /* istanbul ignore next */ 0;
+    emit('exit', process$1.exitCode, null);
+    /* istanbul ignore next */
+    emit('afterexit', process$1.exitCode, null);
+    /* istanbul ignore next */
+    originalProcessReallyExit.call(process$1, process$1.exitCode);
+  };
+
+  var originalProcessEmit = process$1.emit;
+  var processEmit = function processEmit (ev, arg) {
+    if (ev === 'exit' && processOk(commonjsGlobal.process)) {
+      /* istanbul ignore else */
+      if (arg !== undefined) {
+        process$1.exitCode = arg;
+      }
+      var ret = originalProcessEmit.apply(this, arguments);
+      /* istanbul ignore next */
+      emit('exit', process$1.exitCode, null);
+      /* istanbul ignore next */
+      emit('afterexit', process$1.exitCode, null);
+      /* istanbul ignore next */
+      return ret
+    } else {
+      return originalProcessEmit.apply(this, arguments)
+    }
+  };
+}
+
+export { onetime$1 as o, signalExit as s };