@vitest/runner 4.1.0-beta.4 → 4.1.0-beta.5

package/dist/chunk-tasks.js

@@ -249,28 +249,45 @@ function limitConcurrency(concurrency = Infinity) {
 			tail = head && tail;
 		}
 	};
-	return (func, ...args) => {
-		// Create a promise chain that:
-		//  1. Waits for its turn in the task queue (if necessary).
-		//  2. Runs the task.
-		//  3. Allows the next pending task (if any) to run.
+	const acquire = () => {
+		let released = false;
+		const release = () => {
+			if (!released) {
+				released = true;
+				finish();
+			}
+		};
+		if (count++ < concurrency) {
+			return release;
+		}
 		return new Promise((resolve) => {
-			if (count++ < concurrency) {
-				// No need to queue if fewer than maxConcurrency tasks are running.
-				resolve();
-			} else if (tail) {
+			if (tail) {
 				// There are pending tasks, so append to the queue.
-				tail = tail[1] = [resolve];
+				tail = tail[1] = [() => resolve(release)];
 			} else {
 				// No other pending tasks, initialize the queue with a new tail and head.
-				head = tail = [resolve];
+				head = tail = [() => resolve(release)];
+			}
+		});
+	};
+	const limiterFn = (func, ...args) => {
+		function run(release) {
+			try {
+				const result = func(...args);
+				if (result instanceof Promise) {
+					return result.finally(release);
+				}
+				release();
+				return Promise.resolve(result);
+			} catch (error) {
+				release();
+				return Promise.reject(error);
 			}
-		}).then(() => {
-			// Running func here ensures that even a non-thenable result or an
-			// immediately thrown error gets wrapped into a Promise.
-			return func(...args);
-		}).finally(finish);
+		}
+		const release = acquire();
+		return release instanceof Promise ? release.then(run) : run(release);
 	};
+	return Object.assign(limiterFn, { acquire });
 }
 
 /**

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { T as TestArtifact, a as Test, S as Suite, b as SuiteHooks, F as FileSpecification, V as VitestRunner, c as File, d as TaskUpdateEvent, e as Task, f as TestAPI, g as SuiteAPI, h as SuiteCollector } from './tasks.d-C-iOiT8j.js';
-export { A as AfterAllListener, i as AfterEachListener, j as AroundAllListener, k as AroundEachListener, B as BeforeAllListener, l as BeforeEachListener, C as CancelReason, m as FailureScreenshotArtifact, n as Fixture, o as FixtureFn, p as FixtureOptions, q as Fixtures, I as ImportDuration, r as InferFixturesTypes, O as OnTestFailedHandler, s as OnTestFinishedHandler, R as Retry, t as RunMode, u as RuntimeContext, v as SequenceHooks, w as SequenceSetupFiles, x as SerializableRetry, y as SuiteFactory, z as SuiteOptions, D as TaskBase, E as TaskCustomOptions, G as TaskEventPack, H as TaskHook, J as TaskMeta, K as TaskPopulated, L as TaskResult, M as TaskResultPack, N as TaskState, P as TestAnnotation, Q as TestAnnotationArtifact, U as TestAnnotationLocation, W as TestArtifactBase, X as TestArtifactLocation, Y as TestArtifactRegistry, Z as TestAttachment, _ as TestContext, $ as TestFunction, a0 as TestOptions, a1 as TestTagDefinition, a2 as TestTags, a3 as Use, a4 as VisualRegressionArtifact, a5 as VitestRunnerConfig, a6 as VitestRunnerConstructor, a7 as VitestRunnerImportSource, a8 as afterAll, a9 as afterEach, aa as aroundAll, ab as aroundEach, ac as beforeAll, ad as beforeEach, ae as onTestFailed, af as onTestFinished } from './tasks.d-C-iOiT8j.js';
+import { T as TestArtifact, a as Test, S as Suite, b as SuiteHooks, F as FileSpecification, V as VitestRunner, c as File, d as TaskUpdateEvent, e as Task, f as TestAPI, g as SuiteAPI, h as SuiteCollector } from './tasks.d-D2GKpdwQ.js';
+export { A as AfterAllListener, i as AfterEachListener, j as AroundAllListener, k as AroundEachListener, B as BeforeAllListener, l as BeforeEachListener, C as CancelReason, m as FailureScreenshotArtifact, n as Fixture, o as FixtureFn, p as FixtureOptions, q as Fixtures, I as ImportDuration, r as InferFixturesTypes, O as OnTestFailedHandler, s as OnTestFinishedHandler, R as Retry, t as RunMode, u as RuntimeContext, v as SequenceHooks, w as SequenceSetupFiles, x as SerializableRetry, y as SuiteFactory, z as SuiteOptions, D as TaskBase, E as TaskCustomOptions, G as TaskEventPack, H as TaskHook, J as TaskMeta, K as TaskPopulated, L as TaskResult, M as TaskResultPack, N as TaskState, P as TestAnnotation, Q as TestAnnotationArtifact, U as TestAnnotationLocation, W as TestArtifactBase, X as TestArtifactLocation, Y as TestArtifactRegistry, Z as TestAttachment, _ as TestContext, $ as TestFunction, a0 as TestOptions, a1 as TestTagDefinition, a2 as TestTags, a3 as Use, a4 as VisualRegressionArtifact, a5 as VitestRunnerConfig, a6 as VitestRunnerConstructor, a7 as VitestRunnerImportSource, a8 as afterAll, a9 as afterEach, aa as aroundAll, ab as aroundEach, ac as beforeAll, ad as beforeEach, ae as onTestFailed, af as onTestFinished } from './tasks.d-D2GKpdwQ.js';
 import { Awaitable } from '@vitest/utils';
 import '@vitest/utils/diff';
 

package/dist/index.js

@@ -83,7 +83,7 @@ class TestFixtures {
 		"file",
 		"worker"
 	];
-	static _workerContextSymbol = Symbol("workerContext");
+	static _workerContextSuite = { type: "worker" };
 	static clearDefinitions() {
 		TestFixtures._definitions.length = 0;
 	}
@@ -142,10 +142,10 @@ class TestFixtures {
 		return this._suiteContexts.get(file);
 	}
 	getWorkerContext() {
-		if (!this._suiteContexts.has(TestFixtures._workerContextSymbol)) {
-			this._suiteContexts.set(TestFixtures._workerContextSymbol, Object.create(null));
+		if (!this._suiteContexts.has(TestFixtures._workerContextSuite)) {
+			this._suiteContexts.set(TestFixtures._workerContextSuite, Object.create(null));
 		}
-		return this._suiteContexts.get(TestFixtures._workerContextSymbol);
+		return this._suiteContexts.get(TestFixtures._workerContextSuite);
 	}
 	parseUserFixtures(runner, userFixtures, supportNonTest, registrations = new Map(this._registrations)) {
 		const errors = [];
@@ -1106,7 +1106,7 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
 		const stackTraceError = new Error("STACK_TRACE_ERROR");
 		Error.stackTraceLimit = limit;
 		if (handler) {
-			setFn(task, withTimeout(withAwaitAsyncAssertions(withFixtures(handler, { context }), task), timeout, false, stackTraceError, (_, error) => abortIfTimeout([context], error)));
+			setFn(task, withTimeout(withCancel(withAwaitAsyncAssertions(withFixtures(handler, { context }), task), task.context.signal), timeout, false, stackTraceError, (_, error) => abortIfTimeout([context], error)));
 		}
 		if (runner.config.includeTaskLocation) {
 			const error = stackTraceError.stack;
@@ -1640,6 +1640,23 @@ catch (error) {
 		});
 	});
 }
+function withCancel(fn, signal) {
+	return (function runWithCancel(...args) {
+		return new Promise((resolve, reject) => {
+			signal.addEventListener("abort", () => reject(signal.reason));
+			try {
+				const result = fn(...args);
+				if (typeof result === "object" && result != null && typeof result.then === "function") {
+					result.then(resolve, reject);
+				} else {
+					resolve(result);
+				}
+			} catch (error) {
+				reject(error);
+			}
+		});
+	});
+}
 const abortControllers = new WeakMap();
 function abortIfTimeout([context], error) {
 	if (context) {
@@ -1818,6 +1835,7 @@ function mergeHooks(baseHooks, hooks) {
 const now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
 const unixNow = Date.now;
 const { clearTimeout, setTimeout } = getSafeTimers();
+let limitMaxConcurrency;
 /**
 * Normalizes retry configuration to extract individual values.
 * Handles both number and object forms.
@@ -1891,14 +1909,14 @@ async function callTestHooks(runner, test, hooks, sequence) {
 	};
 	if (sequence === "parallel") {
 		try {
-			await Promise.all(hooks.map((fn) => fn(test.context)));
+			await Promise.all(hooks.map((fn) => limitMaxConcurrency(() => fn(test.context))));
 		} catch (e) {
 			failTask(test.result, e, runner.config.diffOptions);
 		}
 	} else {
 		for (const fn of hooks) {
 			try {
-				await fn(test.context);
+				await limitMaxConcurrency(() => fn(test.context));
 			} catch (e) {
 				failTask(test.result, e, runner.config.diffOptions);
 			}
@@ -1920,7 +1938,9 @@ async function callSuiteHook(suite, currentTask, name, runner, args) {
 		updateSuiteHookState(currentTask, name, "run", runner);
 	}
 	async function runHook(hook) {
-		return getBeforeHookCleanupCallback(hook, await hook(...args), name === "beforeEach" ? args[0] : undefined);
+		return limitMaxConcurrency(async () => {
+			return getBeforeHookCleanupCallback(hook, await hook(...args), name === "beforeEach" ? args[0] : undefined);
+		});
 	}
 	if (sequence === "parallel") {
 		callbacks.push(...await Promise.all(hooks.map((hook) => runHook(hook))));
@@ -1964,6 +1984,7 @@ async function callAroundHooks(runInner, options) {
 		await runInner();
 		return;
 	}
+	const hookErrors = [];
 	const createTimeoutPromise = (timeout, phase, stackTraceError) => {
 		let timer;
 		let timedout = false;
@@ -2000,6 +2021,8 @@ async function callAroundHooks(runInner, options) {
 		let useCalled = false;
 		let setupTimeout;
 		let teardownTimeout;
+		let setupLimitConcurrencyRelease;
+		let teardownLimitConcurrencyRelease;
 		// Promise that resolves when use() is called (setup phase complete)
 		let resolveUseCalled;
 		const useCalledPromise = new Promise((resolve) => {
@@ -2032,21 +2055,16 @@ async function callAroundHooks(runInner, options) {
 			resolveUseCalled();
 			// Setup phase completed - clear setup timer
 			setupTimeout.clear();
+			setupLimitConcurrencyRelease?.();
 			// Run inner hooks - don't time this against our teardown timeout
-			let nextError;
-			try {
-				await runNextHook(index + 1);
-			} catch (value) {
-				nextError = { value };
-			}
+			await runNextHook(index + 1).catch((e) => hookErrors.push(e));
+			teardownLimitConcurrencyRelease = await limitMaxConcurrency.acquire();
 			// Start teardown timer after inner hooks complete - only times this hook's teardown code
 			teardownTimeout = createTimeoutPromise(timeout, "teardown", stackTraceError);
 			// Signal that use() is returning (teardown phase starting)
 			resolveUseReturned();
-			if (nextError) {
-				throw nextError.value;
-			}
 		};
+		setupLimitConcurrencyRelease = await limitMaxConcurrency.acquire();
 		// Start setup timeout
 		setupTimeout = createTimeoutPromise(timeout, "setup", stackTraceError);
 		(async () => {
@@ -2058,6 +2076,9 @@ async function callAroundHooks(runInner, options) {
 				resolveHookComplete();
 			} catch (error) {
 				rejectHookComplete(error);
+			} finally {
+				setupLimitConcurrencyRelease?.();
+				teardownLimitConcurrencyRelease?.();
 			}
 		})();
 		// Wait for either: use() to be called OR hook to complete (error) OR setup timeout
@@ -2068,6 +2089,7 @@ async function callAroundHooks(runInner, options) {
 				setupTimeout.promise
 			]);
 		} finally {
+			setupLimitConcurrencyRelease?.();
 			setupTimeout.clear();
 		}
 		// Wait for use() to return (inner hooks complete) OR hook to complete (error during inner hooks)
@@ -2077,10 +2099,14 @@ async function callAroundHooks(runInner, options) {
 		try {
 			await Promise.race([hookCompletePromise, teardownTimeout?.promise]);
 		} finally {
+			teardownLimitConcurrencyRelease?.();
 			teardownTimeout?.clear();
 		}
 	};
-	await runNextHook(0);
+	await runNextHook(0).catch((e) => hookErrors.push(e));
+	if (hookErrors.length > 0) {
+		throw hookErrors;
+	}
 }
 async function callAroundAllHooks(suite, runSuiteInner) {
 	await callAroundHooks(runSuiteInner, {
@@ -2168,14 +2194,14 @@ async function callCleanupHooks(runner, cleanups) {
 			if (typeof fn !== "function") {
 				return;
 			}
-			await fn();
+			await limitMaxConcurrency(() => fn());
 		}));
 	} else {
 		for (const fn of cleanups) {
 			if (typeof fn !== "function") {
 				continue;
 			}
-			await fn();
+			await limitMaxConcurrency(() => fn());
 		}
 	}
 }
@@ -2241,24 +2267,20 @@ async function runTest(test, runner) {
 					test.result.repeatCount = repeatCount;
 					beforeEachCleanups = await $("test.beforeEach", () => callSuiteHook(suite, test, "beforeEach", runner, [test.context, suite]));
 					if (runner.runTask) {
-						await $("test.callback", () => runner.runTask(test));
+						await $("test.callback", () => limitMaxConcurrency(() => runner.runTask(test)));
 					} else {
 						const fn = getFn(test);
 						if (!fn) {
 							throw new Error("Test function is not found. Did you add it using `setFn`?");
 						}
-						await $("test.callback", () => fn());
+						await $("test.callback", () => limitMaxConcurrency(() => fn()));
 					}
 					await runner.onAfterTryTask?.(test, {
 						retry: retryCount,
 						repeats: repeatCount
 					});
 					if (test.result.state !== "fail") {
-						if (!test.repeats) {
-							test.result.state = "pass";
-						} else if (test.repeats && retry === retryCount) {
-							test.result.state = "pass";
-						}
+						test.result.state = "pass";
 					}
 				} catch (e) {
 					failTask(test.result, e, runner.config.diffOptions);
@@ -2358,6 +2380,11 @@ function failTask(result, err, diffOptions) {
 		result.pending = true;
 		return;
 	}
+	if (err instanceof TestRunAbortError) {
+		result.state = "skip";
+		result.note = err.message;
+		return;
+	}
 	result.state = "fail";
 	const errors = Array.isArray(err) ? err : [err];
 	for (const e of errors) {
@@ -2379,6 +2406,22 @@ function markTasksAsSkipped(suite, runner) {
 		}
 	});
 }
+function markPendingTasksAsSkipped(suite, runner, note) {
+	suite.tasks.forEach((t) => {
+		if (!t.result || t.result.state === "run") {
+			t.mode = "skip";
+			t.result = {
+				...t.result,
+				state: "skip",
+				note
+			};
+			updateTask("test-cancel", t, runner);
+		}
+		if (t.type === "suite") {
+			markPendingTasksAsSkipped(t, runner, note);
+		}
+	});
+}
 async function runSuite(suite, runner) {
 	await runner.onBeforeRunSuite?.(suite);
 	if (suite.result?.state === "fail") {
@@ -2479,11 +2522,10 @@ async function runSuite(suite, runner) {
 		updateTask("suite-finished", suite, runner);
 	}
 }
-let limitMaxConcurrency;
 async function runSuiteChild(c, runner) {
 	const $ = runner.trace;
 	if (c.type === "test") {
-		return limitMaxConcurrency(() => $("run.test", {
+		return $("run.test", {
 			"vitest.test.id": c.id,
 			"vitest.test.name": c.name,
 			"vitest.test.mode": c.mode,
@@ -2491,7 +2533,7 @@ async function runSuiteChild(c, runner) {
 			"code.file.path": c.file.filepath,
 			"code.line.number": c.location?.line,
 			"code.column.number": c.location?.column
-		}, () => runTest(c, runner)));
+		}, () => runTest(c, runner));
 	} else if (c.type === "suite") {
 		return $("run.suite", {
 			"vitest.suite.id": c.id,
@@ -2536,7 +2578,10 @@ async function startTests(specs, runner) {
 	runner.cancel = (reason) => {
 		// We intentionally create only one error since there is only one test run that can be cancelled
 		const error = new TestRunAbortError("The test run was aborted by the user.", reason);
-		getRunningTests().forEach((test) => abortContextSignal(test.context, error));
+		getRunningTests().forEach((test) => {
+			abortContextSignal(test.context, error);
+			markPendingTasksAsSkipped(test.file, runner, error.message);
+		});
 		return cancel?.(reason);
 	};
 	if (!workerRunners.has(runner)) {

package/dist/{tasks.d-C-iOiT8j.d.ts → tasks.d-D2GKpdwQ.d.ts}

@@ -213,7 +213,7 @@ declare class TestFixtures {
 	private static _builtinFixtures;
 	private static _fixtureOptionKeys;
 	private static _fixtureScopes;
-	private static _workerContextSymbol;
+	private static _workerContextSuite;
 	static clearDefinitions(): void;
 	static getWorkerContexts(): Record<string, any>[];
 	static getFileContexts(file: File): Record<string, any>[];
@@ -605,7 +605,7 @@ interface TaskEventData {
 	artifact?: TestArtifact | undefined;
 }
 type TaskEventPack = [id: string, event: TaskUpdateEvent, data: TaskEventData | undefined];
-type TaskUpdateEvent = "test-failed-early" | "suite-failed-early" | "test-prepare" | "test-finished" | "test-retried" | "suite-prepare" | "suite-finished" | "before-hook-start" | "before-hook-end" | "after-hook-start" | "after-hook-end" | "test-annotation" | "test-artifact";
+type TaskUpdateEvent = "test-failed-early" | "suite-failed-early" | "test-prepare" | "test-finished" | "test-retried" | "test-cancel" | "suite-prepare" | "suite-finished" | "before-hook-start" | "before-hook-end" | "after-hook-start" | "after-hook-end" | "test-annotation" | "test-artifact";
 interface Suite extends TaskBase {
 	type: "suite";
 	/**

package/dist/types.d.ts

@@ -1,3 +1,3 @@
-export { A as AfterAllListener, i as AfterEachListener, j as AroundAllListener, k as AroundEachListener, B as BeforeAllListener, l as BeforeEachListener, C as CancelReason, m as FailureScreenshotArtifact, c as File, F as FileSpecification, n as Fixture, o as FixtureFn, p as FixtureOptions, q as Fixtures, I as ImportDuration, r as InferFixturesTypes, O as OnTestFailedHandler, s as OnTestFinishedHandler, R as Retry, t as RunMode, u as RuntimeContext, v as SequenceHooks, w as SequenceSetupFiles, x as SerializableRetry, S as Suite, g as SuiteAPI, h as SuiteCollector, y as SuiteFactory, b as SuiteHooks, z as SuiteOptions, e as Task, D as TaskBase, E as TaskCustomOptions, G as TaskEventPack, H as TaskHook, J as TaskMeta, K as TaskPopulated, L as TaskResult, M as TaskResultPack, N as TaskState, d as TaskUpdateEvent, a as Test, f as TestAPI, P as TestAnnotation, Q as TestAnnotationArtifact, U as TestAnnotationLocation, T as TestArtifact, W as TestArtifactBase, X as TestArtifactLocation, Y as TestArtifactRegistry, Z as TestAttachment, _ as TestContext, $ as TestFunction, a0 as TestOptions, a1 as TestTagDefinition, a2 as TestTags, a3 as Use, a4 as VisualRegressionArtifact, V as VitestRunner, a5 as VitestRunnerConfig, a6 as VitestRunnerConstructor, a7 as VitestRunnerImportSource } from './tasks.d-C-iOiT8j.js';
+export { A as AfterAllListener, i as AfterEachListener, j as AroundAllListener, k as AroundEachListener, B as BeforeAllListener, l as BeforeEachListener, C as CancelReason, m as FailureScreenshotArtifact, c as File, F as FileSpecification, n as Fixture, o as FixtureFn, p as FixtureOptions, q as Fixtures, I as ImportDuration, r as InferFixturesTypes, O as OnTestFailedHandler, s as OnTestFinishedHandler, R as Retry, t as RunMode, u as RuntimeContext, v as SequenceHooks, w as SequenceSetupFiles, x as SerializableRetry, S as Suite, g as SuiteAPI, h as SuiteCollector, y as SuiteFactory, b as SuiteHooks, z as SuiteOptions, e as Task, D as TaskBase, E as TaskCustomOptions, G as TaskEventPack, H as TaskHook, J as TaskMeta, K as TaskPopulated, L as TaskResult, M as TaskResultPack, N as TaskState, d as TaskUpdateEvent, a as Test, f as TestAPI, P as TestAnnotation, Q as TestAnnotationArtifact, U as TestAnnotationLocation, T as TestArtifact, W as TestArtifactBase, X as TestArtifactLocation, Y as TestArtifactRegistry, Z as TestAttachment, _ as TestContext, $ as TestFunction, a0 as TestOptions, a1 as TestTagDefinition, a2 as TestTags, a3 as Use, a4 as VisualRegressionArtifact, V as VitestRunner, a5 as VitestRunnerConfig, a6 as VitestRunnerConstructor, a7 as VitestRunnerImportSource } from './tasks.d-D2GKpdwQ.js';
 import '@vitest/utils';
 import '@vitest/utils/diff';

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { S as Suite, c as File, e as Task, a1 as TestTagDefinition, a5 as VitestRunnerConfig, a as Test } from './tasks.d-C-iOiT8j.js';
-export { ag as ChainableFunction, ah as createChainable } from './tasks.d-C-iOiT8j.js';
+import { S as Suite, c as File, e as Task, a1 as TestTagDefinition, a5 as VitestRunnerConfig, a as Test } from './tasks.d-D2GKpdwQ.js';
+export { ag as ChainableFunction, ah as createChainable } from './tasks.d-D2GKpdwQ.js';
 import { ParsedStack, Arrayable } from '@vitest/utils';
 import '@vitest/utils/diff';
 
@@ -19,13 +19,17 @@ declare function createFileTask(filepath: string, root: string, projectName: str
 declare function generateFileHash(file: string, projectName: string | undefined): string;
 declare function findTestFileStackTrace(testFilePath: string, error: string): ParsedStack | undefined;
 
-/**
-* Return a function for running multiple async operations with limited concurrency.
-*/
-declare function limitConcurrency(concurrency?: number): <
+interface ConcurrencyLimiter extends ConcurrencyLimiterFn {
+	acquire: () => (() => void) | Promise<() => void>;
+}
+type ConcurrencyLimiterFn = <
 	Args extends unknown[],
 	T
 >(func: (...args: Args) => PromiseLike<T> | T, ...args: Args) => Promise<T>;
+/**
+* Return a function for running multiple async operations with limited concurrency.
+*/
+declare function limitConcurrency(concurrency?: number): ConcurrencyLimiter;
 
 /**
 * Partition in tasks groups by consecutive concurrent

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/runner",
   "type": "module",
-  "version": "4.1.0-beta.4",
+  "version": "4.1.0-beta.5",
   "description": "Vitest test runner",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -39,7 +39,7 @@
   ],
   "dependencies": {
     "pathe": "^2.0.3",
-    "@vitest/utils": "4.1.0-beta.4"
+    "@vitest/utils": "4.1.0-beta.5"
   },
   "scripts": {
     "build": "premove dist && rollup -c",