vitest 4.0.0-beta.1 → 4.0.0-beta.11

package/dist/suite.d.ts

@@ -1,5 +1,5 @@
-export { g as getBenchFn, a as getBenchOptions } from './chunks/suite.d.FvehnV49.js';
+export { g as getBenchFn, a as getBenchOptions } from './chunks/suite.d.BJWk38HB.js';
 export { VitestRunner, VitestRunnerConfig, createTaskCollector, getCurrentSuite, getCurrentTest, getFn, getHooks, setFn, setHooks } from '@vitest/runner';
 export { createChainable } from '@vitest/runner/utils';
-import './chunks/benchmark.d.BwvBVTda.js';
+import './chunks/benchmark.d.DAaHLpsq.js';
 import 'tinybench';

package/dist/suite.js

@@ -1,5 +1,6 @@
-export { g as getBenchFn, a as getBenchOptions } from './chunks/benchmark.CYdenmiT.js';
+export { g as getBenchFn, a as getBenchOptions } from './chunks/benchmark.LXhJ0F0X.js';
 export { createTaskCollector, getCurrentSuite, getCurrentTest, getFn, getHooks, setFn, setHooks } from '@vitest/runner';
 export { createChainable } from '@vitest/runner/utils';
-import '@vitest/utils';
-import './chunks/utils.XdZDrNZV.js';
+import '@vitest/utils/helpers';
+import './chunks/utils.DGKhod2J.js';
+import '@vitest/utils/timers';

package/dist/worker-base.js

@@ -0,0 +1,203 @@
+import { c as createForksRpcOptions, u as unwrapSerializableConfig, a as createThreadsRpcOptions, e as execute, t as teardown$1 } from './chunks/worker.rPGLlbkW.js';
+import v8 from 'node:v8';
+import { runInThisContext } from 'node:vm';
+import * as spyModule from '@vitest/spy';
+import { EvaluatedModules } from 'vite/module-runner';
+import { s as startVitestModuleRunner, c as createNodeImportMeta } from './chunks/startModuleRunner.oAuCu1yL.js';
+import { performance } from 'node:perf_hooks';
+import { startTests, collectTests } from '@vitest/runner';
+import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './chunks/resolveSnapshotEnvironment.DQVamkje.js';
+import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './chunks/setup-common.NAWRuMRP.js';
+import { g as globalExpect, v as vi } from './chunks/vi.CiJ0Laa6.js';
+import { c as closeInspector } from './chunks/inspector.CvQD-Nie.js';
+import { createRequire } from 'node:module';
+import timers from 'node:timers';
+import timersPromises from 'node:timers/promises';
+import util from 'node:util';
+import { KNOWN_ASSET_TYPES } from '@vitest/utils/constants';
+import { getSafeTimers } from '@vitest/utils/timers';
+import { i as index } from './chunks/index.AZOjjqWP.js';
+import { g as getWorkerState, r as resetModules, p as provideWorkerState } from './chunks/utils.DGKhod2J.js';
+import '@vitest/utils/source-map';
+import 'node:fs';
+import 'node:url';
+import 'pathe';
+import './chunks/index.DIWhzsUh.js';
+import 'node:console';
+import './chunks/rpc.jKGRSXIH.js';
+import './chunks/index.Bgo3tNWt.js';
+import '@vitest/utils/helpers';
+import './path.js';
+import 'node:path';
+import '@vitest/utils/serialize';
+import './module-evaluator.js';
+import '@vitest/mocker';
+import '@vitest/expect';
+import './chunks/test.KC5tH8hC.js';
+import './chunks/benchmark.LXhJ0F0X.js';
+import '@vitest/runner/utils';
+import '@vitest/utils/error';
+import './chunks/coverage.D_JHT54q.js';
+import '@vitest/snapshot';
+import './chunks/_commonjsHelpers.BFTU3MAI.js';
+import '@vitest/utils/offset';
+import './chunks/date.-jtEtIeV.js';
+import 'expect-type';
+
+// this should only be used in Node
+let globalSetup = false;
+async function setupGlobalEnv(config, { environment }, moduleRunner) {
+	await setupCommonEnv(config), Object.defineProperty(globalThis, "__vitest_index__", {
+		value: index,
+		enumerable: false
+	});
+	const state = getWorkerState();
+	if (!state.config.snapshotOptions.snapshotEnvironment) state.config.snapshotOptions.snapshotEnvironment = await resolveSnapshotEnvironment(config, moduleRunner);
+	if (globalSetup) return;
+	globalSetup = true;
+	const viteEnvironment = environment.viteEnvironment || environment.name;
+	if (viteEnvironment === "client") {
+		const _require = createRequire(import.meta.url);
+		_require.extensions[".css"] = resolveCss, _require.extensions[".scss"] = resolveCss, _require.extensions[".sass"] = resolveCss, _require.extensions[".less"] = resolveCss, KNOWN_ASSET_TYPES.forEach((type) => {
+			_require.extensions[`.${type}`] = resolveAsset;
+		}), process.env.SSR = "";
+	} else process.env.SSR = "1";
+	if (globalThis.__vitest_required__ = {
+		util,
+		timers,
+		timersPromises
+	}, !config.disableConsoleIntercept) await setupConsoleLogSpy();
+}
+function resolveCss(mod) {
+	mod.exports = "";
+}
+function resolveAsset(mod, url) {
+	mod.exports = url;
+}
+async function setupConsoleLogSpy() {
+	const { createCustomConsole } = await import('./chunks/console.CiTi59Jy.js');
+	globalThis.console = createCustomConsole();
+}
+async function withEnv({ environment }, options, fn) {
+	globalThis.__vitest_environment__ = environment.name, globalExpect.setState({ environment: environment.name });
+	const env = await environment.setup(globalThis, options);
+	try {
+		await fn();
+	} finally {
+		// Run possible setTimeouts, e.g. the onces used by ConsoleLogSpy
+		const { setTimeout } = getSafeTimers();
+		await new Promise((resolve) => setTimeout(resolve)), await env.teardown(globalThis);
+	}
+}
+
+// browser shouldn't call this!
+async function run$1(method, files, config, environment, moduleRunner) {
+	const workerState = getWorkerState(), isIsolatedThreads = config.pool === "threads" && (config.poolOptions?.threads?.isolate ?? true), isIsolatedForks = config.pool === "forks" && (config.poolOptions?.forks?.isolate ?? true), isolate = isIsolatedThreads || isIsolatedForks;
+	if (await setupGlobalEnv(config, environment, moduleRunner), await startCoverageInsideWorker(config.coverage, moduleRunner, { isolate }), config.chaiConfig) setupChaiConfig(config.chaiConfig);
+	const runner = await resolveTestRunner(config, moduleRunner);
+	workerState.onCancel.then((reason) => {
+		closeInspector(config), runner.cancel?.(reason);
+	}), workerState.durations.prepare = performance.now() - workerState.durations.prepare, workerState.durations.environment = performance.now(), await withEnv(environment, environment.options || config.environmentOptions || {}, async () => {
+		workerState.durations.environment = performance.now() - workerState.durations.environment;
+		for (const file of files) {
+			if (isolate) moduleRunner.mocker.reset(), resetModules(workerState.evaluatedModules, true);
+			if (workerState.filepath = file.filepath, method === "run") await startTests([file], runner);
+			else await collectTests([file], runner);
+			// mocks should not affect different files
+			vi.resetConfig(), vi.restoreAllMocks();
+		}
+		await stopCoverageInsideWorker(config.coverage, moduleRunner, { isolate });
+	}), workerState.environmentTeardownRun = true;
+}
+
+let _moduleRunner;
+const evaluatedModules = new EvaluatedModules(), moduleExecutionInfo = /* @__PURE__ */ new Map();
+function startModuleRunner(options) {
+	return _moduleRunner || (_moduleRunner = startVitestModuleRunner(options), _moduleRunner);
+}
+async function runBaseTests(method, state) {
+	const { ctx } = state;
+	if (state.evaluatedModules = evaluatedModules, state.moduleExecutionInfo = moduleExecutionInfo, provideWorkerState(globalThis, state), ctx.invalidates) ctx.invalidates.forEach((filepath) => {
+		const modules = state.evaluatedModules.fileToModulesMap.get(filepath) || [];
+		modules.forEach((module) => {
+			state.evaluatedModules.invalidateModule(module);
+		});
+	});
+	ctx.files.forEach((i) => {
+		const filepath = typeof i === "string" ? i : i.filepath, modules = state.evaluatedModules.fileToModulesMap.get(filepath) || [];
+		modules.forEach((module) => {
+			state.evaluatedModules.invalidateModule(module);
+		});
+	});
+	const executor = startModuleRunner({
+		state,
+		evaluatedModules: state.evaluatedModules,
+		spyModule,
+		createImportMeta: createNodeImportMeta
+	}), fileSpecs = ctx.files.map((f) => typeof f === "string" ? {
+		filepath: f,
+		testLocations: void 0
+	} : f);
+	// we could load @vite/env, but it would take ~8ms, while this takes ~0,02ms
+	if (ctx.config.serializedDefines) try {
+		runInThisContext(`(() =>{\n${ctx.config.serializedDefines}})()`, {
+			lineOffset: 1,
+			filename: "virtual:load-defines.js"
+		});
+	} catch (error) {
+		throw new Error(`Failed to load custom "defines": ${error.message}`);
+	}
+	await run$1(method, fileSpecs, ctx.config, {
+		environment: state.environment,
+		options: ctx.environment.options
+	}, executor);
+}
+
+class ForksBaseWorker {
+	getRpcOptions() {
+		return createForksRpcOptions(v8);
+	}
+	async executeTests(method, state) {
+		// TODO: don't rely on reassigning process.exit
+		// https://github.com/vitest-dev/vitest/pull/4441#discussion_r1443771486
+		const exit = process.exit;
+		state.ctx.config = unwrapSerializableConfig(state.ctx.config);
+		try {
+			await runBaseTests(method, state);
+		} finally {
+			process.exit = exit;
+		}
+	}
+	runTests(state) {
+		return this.executeTests("run", state);
+	}
+	collectTests(state) {
+		return this.executeTests("collect", state);
+	}
+}
+const worker$1 = new ForksBaseWorker();
+
+class ThreadsBaseWorker {
+	getRpcOptions(ctx) {
+		return createThreadsRpcOptions(ctx);
+	}
+	runTests(state) {
+		return runBaseTests("run", state);
+	}
+	collectTests(state) {
+		return runBaseTests("collect", state);
+	}
+}
+const worker = new ThreadsBaseWorker();
+
+async function run(ctx) {
+	await execute("run", ctx, ctx.pool === "forks" ? worker$1 : worker);
+}
+async function collect(ctx) {
+	await execute("collect", ctx, ctx.pool === "forks" ? worker$1 : worker);
+}
+async function teardown() {
+	await teardown$1();
+}
+
+export { collect, run, teardown };