vitest 5.0.4 → 5.1.0-beta.1

package/dist/chunks/{index.CPNMO3h-.js → index.BFXLpwll.js}

@@ -5,6 +5,7 @@ import { E as EnvironmentTeardownError, a as getSafeWorkerState } from './utils.
 import { pathToFileURL, URL as URL$1 } from 'node:url';
 import { distDir } from '../path.js';
 import { VitestModuleEvaluator, unwrapId } from '../module-evaluator.js';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { isAbsolute, resolve } from 'node:path';
 import vm from 'node:vm';
 import { MockerRegistry, mockObject, RedirectedModule, AutomockedModule } from '@vitest/mocker';
@@ -48,7 +49,9 @@ class BareModuleMocker {
 		return this.registries.get(suite);
 	}
 	reset() {
+		for (const registry of this.registries.values()) for (const url of registry.keys()) this.invalidateModuleById(registry.get(url).id);
 		this.registries.clear();
+		BareModuleMocker.pendingIds = [];
 	}
 	invalidateModuleById(_id) {
 		// implemented by mockers that control the module runner
@@ -102,10 +105,20 @@ class BareModuleMocker {
 			};
 		});
 	}
+	registeringMocks;
 	async resolveMocks() {
-		if (!BareModuleMocker.pendingIds.length) return;
-		const pendingIds = BareModuleMocker.pendingIds;
-		BareModuleMocker.pendingIds = [];
+		if (BareModuleMocker.pendingIds.length) {
+			const pendingIds = BareModuleMocker.pendingIds;
+			BareModuleMocker.pendingIds = [];
+			const registration = this.registerMocks(pendingIds, this.registeringMocks).finally(() => {
+				if (this.registeringMocks === registration) this.registeringMocks = void 0;
+			});
+			this.registeringMocks = registration;
+		}
+		await this.registeringMocks;
+	}
+	async registerMocks(pendingIds, previous) {
+		await previous?.catch(() => {});
 		const resolveMock = async (mock) => {
 			return {
 				mock,
@@ -273,6 +286,9 @@ class VitestMocker extends BareModuleMocker {
 	moduleRunner;
 	options;
 	filterPublicKeys;
+	// factories that run in the current async context, the innermost is last
+	factoryContexts = new AsyncLocalStorage();
+	pendingFactories = /* @__PURE__ */ new Map();
 	constructor(moduleRunner, options) {
 		super(options);
 		this.moduleRunner = moduleRunner;
@@ -304,17 +320,50 @@ class VitestMocker extends BareModuleMocker {
 		if (this.spyModule) return;
 		this.spyModule = await this.moduleRunner.import(spyModulePath);
 	}
-	reset() {
-		this.registries.clear();
-	}
 	invalidateModuleById(id) {
 		const mockId = this.getMockPath(id);
+		this.pendingFactories.delete(mockId);
 		const node = this.evaluatedModules.getModuleById(mockId);
 		if (node) {
 			this.evaluatedModules.invalidateModule(node);
 			node.mockedExports = void 0;
 		}
 	}
+	getMockContext() {
+		return { callstack: (this.factoryContexts.getStore()?.findLast((context) => this.pendingFactories.has(context.mockId)))?.callstack ?? null };
+	}
+	/**
+	* Whether the factory of this mock runs in the current async context,
+	* or waits for a factory that runs in it. Such imports get the original module.
+	* The callstack cannot tell it: all imports from one module share the same array.
+	*/
+	isResolvingMock(mockId) {
+		if (!this.pendingFactories.has(mockId)) return false;
+		return (this.factoryContexts.getStore() ?? []).some((context) => context.mockId === mockId) || this.waitsForCurrentFactory(mockId);
+	}
+	/**
+	* Whether the module is still evaluating and waits for a factory
+	* that runs in the current async context.
+	*/
+	isWaitingForFactory(mod) {
+		return !!mod.promise && !mod.evaluated && this.waitsForCurrentFactory(mod.id);
+	}
+	waitsForCurrentFactory(id) {
+		const factories = (this.factoryContexts.getStore() ?? []).map((context) => context.mockId);
+		const visited = new Set(factories);
+		// a factory that waits for the current one makes everything that waits for it wait too
+		while (factories.length) {
+			const waiting = this.pendingFactories.get(factories.pop())?.waiting;
+			if (waiting?.has(id)) return true;
+			waiting?.forEach((waiter) => {
+				if (this.pendingFactories.has(waiter) && !visited.has(waiter)) {
+					visited.add(waiter);
+					factories.push(waiter);
+				}
+			});
+		}
+		return false;
+	}
 	ensureModule(id, url) {
 		const node = this.evaluatedModules.ensureModule(id, url);
 		// TODO
@@ -327,9 +376,53 @@ class VitestMocker extends BareModuleMocker {
 		};
 		return node;
 	}
-	async callFunctionMock(id, url, mock) {
+	callFunctionMock(id, url, mock, callstack) {
 		const node = this.ensureModule(id, url);
-		if (node.exports) return node.exports;
+		if (node.exports) return Promise.resolve(node.exports);
+		return this.resolveMockOnce(id, callstack, () => this.resolveFunctionMock(node, mock));
+	}
+	resolveMockOnce(id, callstack, resolve) {
+		const contexts = this.factoryContexts.getStore() ?? [];
+		const waiting = [...callstack, ...contexts.map((context) => context.mockId)];
+		const pending = this.pendingFactories.get(id);
+		if (pending) {
+			waiting.forEach((waiter) => pending.waiting.add(waiter));
+			return pending.promise;
+		}
+		const factory = {
+			promise: this.factoryContexts.run([...contexts, {
+				mockId: id,
+				callstack
+			}], resolve).finally(() => {
+				if (this.pendingFactories.get(id) === factory) this.pendingFactories.delete(id);
+				if (!this.pendingFactories.size)
+ // an enabled storage slows down every promise on Node 22
+				this.factoryContexts.disable();
+			}),
+			waiting: new Set(waiting)
+		};
+		this.pendingFactories.set(id, factory);
+		return factory.promise;
+	}
+	async resolveAutomock(url, mockId, evaluatedNode, callstack, type) {
+		const Object = this.primitives.Object;
+		// we have to define a separate object that will copy all properties into itself
+		// and can't just use the same `exports` define automatically by Vite before the evaluator
+		const exports = Object.create(null);
+		Object.defineProperty(exports, Symbol.toStringTag, {
+			value: "Module",
+			configurable: true,
+			writable: true
+		});
+		const node = this.ensureModule(mockId, this.getMockPath(evaluatedNode.url));
+		node.meta = evaluatedNode.meta;
+		node.file = evaluatedNode.file;
+		node.mockedExports = exports;
+		const mod = await this.moduleRunner.cachedRequest(url, node, callstack, void 0, true);
+		this.mockObject(mod, exports, type);
+		return exports;
+	}
+	async resolveFunctionMock(node, mock) {
 		const exports = await mock.resolve();
 		const moduleExports = new Proxy(exports, { get: (target, prop) => {
 			const val = target[prop];
@@ -373,7 +466,10 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 			const Object = this.primitives.Object;
 			return this.mockObject(mod, Object.create(Object.prototype), mock.type);
 		}
-		if (mock.type === "manual") return this.callFunctionMock(id, url, mock);
+		if (mock.type === "manual") {
+			const mockId = this.getMockPath(id);
+			return this.callFunctionMock(mockId, this.getMockPath(url), mock, [importer, mockId]);
+		}
 		const node = await this.moduleRunner.fetchModule(mock.redirect);
 		return this.moduleRunner.cachedRequest(mock.redirect, node, [importer], void 0, true);
 	}
@@ -389,36 +485,14 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 			});
 			if (mock.type === "automock" || mock.type === "autospy") {
 				const cache = this.evaluatedModules.getModuleById(mockId);
-				if (cache && cache.mockedExports) return cache.mockedExports;
-				const Object = this.primitives.Object;
-				// we have to define a separate object that will copy all properties into itself
-				// and can't just use the same `exports` define automatically by Vite before the evaluator
-				const exports = Object.create(null);
-				Object.defineProperty(exports, Symbol.toStringTag, {
-					value: "Module",
-					configurable: true,
-					writable: true
-				});
-				const node = this.ensureModule(mockId, this.getMockPath(evaluatedNode.url));
-				node.meta = evaluatedNode.meta;
-				node.file = evaluatedNode.file;
-				node.mockedExports = exports;
-				const mod = await this.moduleRunner.cachedRequest(url, node, callstack, void 0, true);
-				this.mockObject(mod, exports, mock.type);
-				return exports;
-			}
-			if (mock.type === "manual" && !callstack.includes(mockId) && !callstack.includes(url)) try {
-				callstack.push(mockId);
-				// this will not work if user does Promise.all(import(), import())
-				// we can also use AsyncLocalStorage to store callstack, but this won't work in the browser
-				// maybe we should improve mock API in the future?
-				this.mockContext.callstack = callstack;
-				return await this.callFunctionMock(mockId, this.getMockPath(url), mock);
-			} finally {
-				this.mockContext.callstack = null;
-				const indexMock = callstack.indexOf(mockId);
-				callstack.splice(indexMock, 1);
+				if (cache?.mockedExports) {
+					// while the original module evaluates, only its own imports get the partial object, like in a cycle
+					const isSelfImport = callstack.includes(evaluatedNode.id) || this.isResolvingMock(mockId);
+					if (!this.pendingFactories.has(mockId) || isSelfImport) return cache.mockedExports;
+				}
+				return this.resolveMockOnce(mockId, [...callstack, mockId], () => this.resolveAutomock(url, mockId, evaluatedNode, callstack, mock.type));
 			}
+			if (mock.type === "manual" && !callstack.includes(mockId) && !callstack.includes(url) && !this.isResolvingMock(mockId)) return this.callFunctionMock(mockId, this.getMockPath(url), mock, [...callstack, mockId]);
 			else if (mock.type === "redirect" && !callstack.includes(mock.redirect)) {
 				span.setAttribute("vitest.mock.redirect", mock.redirect);
 				return mock.redirect;
@@ -575,10 +649,11 @@ class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
 	async cachedRequest(url, mod, callstack = [], metadata, ignoreMock = false) {
 		// Track for a better error message if dynamic import is not resolved properly
 		this._callstacks.set(mod, callstack);
+		// the factory imports a module that waits for this factory, treat it as a cycle
+		if (mod.exports && this.mocker.isWaitingForFactory(mod)) return mod.exports;
 		if (ignoreMock) return this._cachedRequest(url, mod, callstack, metadata);
 		let mocked;
 		if (mod.meta && "mockedModule" in mod.meta) {
-			const mockedModule = mod.meta.mockedModule;
 			const mockId = this.mocker.getMockPath(mod.id);
 			const currentMock = this.mocker.getDependencyMock(mod.id);
 			// bypass mock and force "importActual" behavior when:
@@ -587,11 +662,11 @@ class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
 				const node = await this.fetchModule(injectQuery(url, "_vitest_original"));
 				return this._cachedRequest(node.url, node, callstack, metadata);
 			}
-			if (callstack.includes(mockId) || callstack.includes(url) || "redirect" in currentMock && callstack.includes(currentMock.redirect)) {
+			if (callstack.includes(mockId) || this.mocker.isResolvingMock(mockId) || callstack.includes(url) || "redirect" in currentMock && callstack.includes(currentMock.redirect)) {
 				const node = await this.fetchModule(injectQuery(url, "_vitest_original"));
 				return this._cachedRequest(node.url, node, callstack, metadata);
 			}
-			if ((currentMock.type === "automock" || currentMock.type === "autospy") && currentMock !== mockedModule) {
+			if (currentMock.type === "automock" || currentMock.type === "autospy") {
 				const freshNode = await this.fetchModule(injectQuery(url, "_vitest_original"));
 				mocked = await this.mocker.requestWithMockedModule(url, freshNode, callstack, currentMock);
 			} else mocked = await this.mocker.requestWithMockedModule(url, mod, callstack, currentMock);
@@ -760,7 +835,7 @@ function startVitestModuleRunner(options) {
 				const rawId = unwrapId(id);
 				resolvingModules.add(rawId);
 				try {
-					if (VitestMocker.pendingIds.length) await moduleRunner.mocker.resolveMocks();
+					if (VitestMocker.pendingIds.length || moduleRunner.mocker.registeringMocks) await moduleRunner.mocker.resolveMocks();
 					if (!isImportActual) {
 						const resolvedMock = moduleRunner.mocker.getDependencyMockByUrl(id);
 						if (resolvedMock?.type === "manual" || resolvedMock?.type === "redirect") return {
@@ -769,7 +844,8 @@ function startVitestModuleRunner(options) {
 							id: resolvedMock.id,
 							url: resolvedMock.url,
 							invalidate: false,
-							mockedModule: resolvedMock
+							// the module node outlives the test file, so it must not keep the mock factory alive
+							mockedModule: true
 						};
 					}
 					if (isBuiltin(rawId)) return {

package/dist/chunks/{index.uwTEEBsB.js → index.BXttT2gP.js}

@@ -1,6 +1,6 @@
-import { b as printDiffOrStringify, d as diff, a as processError, T as TestSyntaxError, g as getCurrentTest, c as createTaskCollector, e as getCurrentSuite, f as createChainable, h as getHooks, i as getFn, m as matchesTags, j as afterAll, k as afterEach, l as aroundAll, n as aroundEach, o as beforeAll, q as beforeEach, r as describe, t as it, u as onTestFailed, v as onTestFinished, w as recordArtifact, x as suite, y as test } from './run.Cm2sd7-x.js';
+import { b as printDiffOrStringify, d as diff, a as processError, T as TestSyntaxError, g as getCurrentTest, c as createTaskCollector, e as getCurrentSuite, f as createChainable, h as getHooks, i as getFn, m as matchesTags, j as afterAll, k as afterEach, l as aroundAll, n as aroundEach, o as beforeAll, q as beforeEach, r as describe, t as it, u as onTestFailed, v as onTestFinished, w as recordArtifact, x as suite, y as test } from './run.BfrMbGVD.js';
 import { i as isChildProcess, r as resetModules, g as getWorkerState } from './utils.DYj33du9.js';
-import { e as parseErrorStacktrace, a as getSafeTimers, f as parseSingleStack, h as delay } from './source-map.DdKI5IHB.js';
+import { e as parseErrorStacktrace, a as getSafeTimers, f as parseSingleStack, h as delay } from './source-map.BjWcsIL9.js';
 import { i as isMockFunction, f as fn, a as spyOn, r as restoreAllMocks, b as resetAllMocks, c as clearAllMocks } from './spy.DDMXghXv.js';
 import { u as isObject, B as getCallLastIndex, g as getType, D as noop, x as assertTypes, w as ordinal, E as createSimpleStackTrace, i as isAbsolute, a as relative, n as normalize } from './pathe.M-eThtNZ.Ba-7h1rE.js';
 import { g as getDefaultExportFromCjs, f as format, a as commonjsGlobal } from './index.D0heQG4v.js';
@@ -11,7 +11,7 @@ import { use, util } from 'chai';
 import { getNames, getTests, getTestName, createFileTask } from '../task-utils.js';
 import { g as getSerializers, a as addSerializer } from './plugins.DPQHVT0p.js';
 import { p as positionToOffset, o as offsetToLineNumber, l as lineSplitRE } from './offset.Dy-5Fdfn.js';
-import { r as rpc, V as VitestEvaluatedModules } from './rpc.DpkUyY1N.js';
+import { r as rpc, V as VitestEvaluatedModules } from './rpc.BV0XpJ5q.js';
 import { Bench } from 'tinybench';
 import { expectTypeOf } from 'expect-type';
 
@@ -3643,19 +3643,6 @@ function requireFakeTimersSrc () {
 	hasRequiredFakeTimersSrc = 1;
 
 	const globalObject = requireLib().global;
-	let timersModule, timersPromisesModule;
-	if (typeof __vitest_required__ !== 'undefined') {
-	    try {
-	        timersModule = __vitest_required__.timers;
-	    } catch {
-	        // ignored
-	    }
-	    try {
-	        timersPromisesModule = __vitest_required__.timersPromises;
-	    } catch {
-	        // ignored
-	    }
-	}
 
 	/**
 	 * @typedef {"nextAsync" | "manual" | "interval"} TickMode
@@ -4179,7 +4166,8 @@ function requireFakeTimersSrc () {
 	        isPresent.hrtime && typeof _global.process.hrtime.bigint === "function";
 	    isPresent.nextTick =
 	        _global.process && typeof _global.process.nextTick === "function";
-	    const utilPromisify = _global.process && _global.__vitest_required__ && _global.__vitest_required__.util.promisify;
+	    const utilPromisify =
+	        _global.process && _global.__vitest_required__?.util.promisify;
 	    isPresent.performance =
 	        _global.performance && typeof _global.performance.now === "function";
 	    const hasPerformancePrototype =
@@ -6219,6 +6207,7 @@ function requireFakeTimersSrc () {
 	        clock.uninstall = function () {
 	            uninstalled = true;
 	            clock.setTickMode({ mode: "manual" });
+	            const { timersModule, timersPromisesModule } = clock;
 
 	            if (clock.methods) {
 	                const installedHrTime = "_hrtime";
@@ -6392,6 +6381,16 @@ function requireFakeTimersSrc () {
 	        const clock = createClock(config.now, config.loopLimit);
 	        clock.shouldClearNativeTimers = config.shouldClearNativeTimers;
 
+	        // Vitest injects Node builtins because this file is bundled without require.
+	        const vitestRequired =
+	            config.fakeNodeBuiltins && _global.__vitest_required__;
+	        const timersModule = vitestRequired?.timers;
+	        const timersPromisesModule = vitestRequired?.timersPromises;
+	        const syncBuiltinESMExports = vitestRequired?.syncBuiltinESMExports;
+	        // Keep the modules on the clock so uninstall can restore their methods.
+	        clock.timersModule = timersModule;
+	        clock.timersPromisesModule = timersPromisesModule;
+
 	        clock.abortListenerMap = new Map();
 
 	        if (hasToFake) {
@@ -6733,6 +6732,21 @@ function requireFakeTimersSrc () {
 	            }
 	        }
 
+	        // Keep ESM named exports in sync with the patched CommonJS modules.
+	        if (
+	            syncBuiltinESMExports &&
+	            (clock.timersModuleMethods?.length ||
+	                clock.timersPromisesModuleMethods?.length)
+	        ) {
+	            const uninstall = clock.uninstall;
+	            clock.uninstall = () => {
+	                const result = uninstall();
+	                syncBuiltinESMExports();
+	                return result;
+	            };
+	            syncBuiltinESMExports();
+	        }
+
 	        return clock;
 	    }
 
@@ -6872,7 +6886,8 @@ class FakeTimers {
 		}
 	}
 	setSystemTime(now) {
-		const date = typeof now === "undefined" || now instanceof Date ? now : new Date(now);
+		const normalized = normalizeSystemTime(now);
+		const date = typeof normalized === "undefined" || normalized instanceof Date ? normalized : new Date(normalized);
 		if (this._fakingTime) this._clock.setSystemTime(date);
 		else {
 			const newFakingDate = date ?? new Date(this.getRealSystemTime());
@@ -6921,6 +6936,10 @@ class FakeTimers {
 		return this._fakingTime;
 	}
 }
+// Like fake-timers, read epochMilliseconds from Instant or ZonedDateTime without requiring built-in Temporal types.
+function normalizeSystemTime(time) {
+	return time && typeof time === "object" && "epochMilliseconds" in time ? time.epochMilliseconds : time;
+}
 
 const whenSymbol = Symbol.for("$$vitest:when");
 /**