@vitest/runner 2.1.3 → 2.1.5

package/dist/chunk-tasks.js

@@ -2,48 +2,31 @@ import { processError } from '@vitest/utils/error';
 import { relative } from 'pathe';
 import { toArray } from '@vitest/utils';
 
-function partitionSuiteChildren(suite) {
-  let tasksGroup = [];
-  const tasksGroups = [];
-  for (const c of suite.tasks) {
-    if (tasksGroup.length === 0 || c.concurrent === tasksGroup[0].concurrent) {
-      tasksGroup.push(c);
-    } else {
-      tasksGroups.push(tasksGroup);
-      tasksGroup = [c];
+function createChainable(keys, fn) {
+  function create(context) {
+    const chain2 = function(...args) {
+      return fn.apply(context, args);
+    };
+    Object.assign(chain2, fn);
+    chain2.withContext = () => chain2.bind(context);
+    chain2.setContext = (key, value) => {
+      context[key] = value;
+    };
+    chain2.mergeContext = (ctx) => {
+      Object.assign(context, ctx);
+    };
+    for (const key of keys) {
+      Object.defineProperty(chain2, key, {
+        get() {
+          return create({ ...context, [key]: true });
+        }
+      });
     }
+    return chain2;
   }
-  if (tasksGroup.length > 0) {
-    tasksGroups.push(tasksGroup);
-  }
-  return tasksGroups;
-}
-
-function limitConcurrency(concurrency = Infinity) {
-  let count = 0;
-  let head;
-  let tail;
-  const finish = () => {
-    count--;
-    if (head) {
-      head[0]();
-      head = head[1];
-      tail = head && tail;
-    }
-  };
-  return (func, ...args) => {
-    return new Promise((resolve) => {
-      if (count++ < concurrency) {
-        resolve();
-      } else if (tail) {
-        tail = tail[1] = [resolve];
-      } else {
-        head = tail = [resolve];
-      }
-    }).then(() => {
-      return func(...args);
-    }).finally(finish);
-  };
+  const chain = create({});
+  chain.fn = fn;
+  return chain;
 }
 
 function interpretTaskModes(suite, namePattern, onlyMode, parentIsOnly, allowOnly) {
@@ -151,31 +134,48 @@ function createFileTask(filepath, root, projectName, pool) {
   return file;
 }
 
-function createChainable(keys, fn) {
-  function create(context) {
-    const chain2 = function(...args) {
-      return fn.apply(context, args);
-    };
-    Object.assign(chain2, fn);
-    chain2.withContext = () => chain2.bind(context);
-    chain2.setContext = (key, value) => {
-      context[key] = value;
-    };
-    chain2.mergeContext = (ctx) => {
-      Object.assign(context, ctx);
-    };
-    for (const key of keys) {
-      Object.defineProperty(chain2, key, {
-        get() {
-          return create({ ...context, [key]: true });
-        }
-      });
+function limitConcurrency(concurrency = Infinity) {
+  let count = 0;
+  let head;
+  let tail;
+  const finish = () => {
+    count--;
+    if (head) {
+      head[0]();
+      head = head[1];
+      tail = head && tail;
+    }
+  };
+  return (func, ...args) => {
+    return new Promise((resolve) => {
+      if (count++ < concurrency) {
+        resolve();
+      } else if (tail) {
+        tail = tail[1] = [resolve];
+      } else {
+        head = tail = [resolve];
+      }
+    }).then(() => {
+      return func(...args);
+    }).finally(finish);
+  };
+}
+
+function partitionSuiteChildren(suite) {
+  let tasksGroup = [];
+  const tasksGroups = [];
+  for (const c of suite.tasks) {
+    if (tasksGroup.length === 0 || c.concurrent === tasksGroup[0].concurrent) {
+      tasksGroup.push(c);
+    } else {
+      tasksGroups.push(tasksGroup);
+      tasksGroup = [c];
     }
-    return chain2;
   }
-  const chain = create({});
-  chain.fn = fn;
-  return chain;
+  if (tasksGroup.length > 0) {
+    tasksGroups.push(tasksGroup);
+  }
+  return tasksGroups;
 }
 
 function isAtomTest(s) {
@@ -239,5 +239,11 @@ function getNames(task) {
   }
   return names;
 }
+function getFullName(task, separator = " > ") {
+  return getNames(task).join(separator);
+}
+function getTestName(task, separator = " > ") {
+  return getNames(task).slice(1).join(separator);
+}
 
-export { createFileTask as a, isAtomTest as b, calculateSuiteHash as c, getTests as d, getTasks as e, getSuites as f, generateHash as g, hasTests as h, interpretTaskModes as i, hasFailed as j, getNames as k, createChainable as l, limitConcurrency as m, partitionSuiteChildren as p, someTasksAreOnly as s };
+export { calculateSuiteHash as a, createFileTask as b, createChainable as c, getFullName as d, getNames as e, getSuites as f, generateHash as g, getTasks as h, interpretTaskModes as i, getTestName as j, getTests as k, limitConcurrency as l, hasFailed as m, hasTests as n, isAtomTest as o, partitionSuiteChildren as p, someTasksAreOnly as s };

package/dist/index.d.ts

@@ -1,11 +1,130 @@
+import { B as BeforeAllListener, A as AfterAllListener, d as BeforeEachListener, e as AfterEachListener, f as TaskHook, O as OnTestFailedHandler, g as OnTestFinishedHandler, a as Test, C as Custom, S as Suite, h as SuiteHooks, T as Task, F as File, i as SuiteAPI, j as TestAPI, k as SuiteCollector } from './tasks-3ZnPj1LR.js';
+export { D as DoneCallback, E as ExtendedContext, l as Fixture, m as FixtureFn, n as FixtureOptions, o as Fixtures, H as HookCleanupCallback, p as HookListener, I as InferFixturesTypes, R as RunMode, q as RuntimeContext, r as SequenceHooks, s as SequenceSetupFiles, t as SuiteFactory, u as TaskBase, v as TaskContext, w as TaskCustomOptions, x as TaskMeta, y as TaskPopulated, z as TaskResult, G as TaskResultPack, J as TaskState, K as TestContext, L as TestFunction, M as TestOptions, U as Use } from './tasks-3ZnPj1LR.js';
+import { Awaitable } from '@vitest/utils';
 import { VitestRunner } from './types.js';
 export { CancelReason, VitestRunnerConfig, VitestRunnerConstructor, VitestRunnerImportSource } from './types.js';
-import { T as Task, F as File, d as SuiteAPI, e as TestAPI, f as SuiteCollector, g as CustomAPI, B as BeforeAllListener, A as AfterAllListener, h as BeforeEachListener, i as AfterEachListener, j as TaskHook, O as OnTestFailedHandler, k as OnTestFinishedHandler, a as Test, C as Custom, S as Suite, l as SuiteHooks } from './tasks-SNKRxoD7.js';
-export { D as DoneCallback, L as ExtendedContext, w as Fixture, v as FixtureFn, u as FixtureOptions, x as Fixtures, y as HookCleanupCallback, H as HookListener, I as InferFixturesTypes, R as RunMode, G as RuntimeContext, M as SequenceHooks, N as SequenceSetupFiles, E as SuiteFactory, n as TaskBase, K as TaskContext, z as TaskCustomOptions, p as TaskMeta, o as TaskPopulated, q as TaskResult, r as TaskResultPack, m as TaskState, J as TestContext, s as TestFunction, t as TestOptions, U as Use } from './tasks-SNKRxoD7.js';
-import { Awaitable } from '@vitest/utils';
 export { processError } from '@vitest/utils/error';
 import '@vitest/utils/diff';
 
+/**
+ * Registers a callback function to be executed once before all tests within the current suite.
+ * This hook is useful for scenarios where you need to perform setup operations that are common to all tests in a suite, such as initializing a database connection or setting up a test environment.
+ *
+ * **Note:** The `beforeAll` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
+ *
+ * @param {Function} fn - The callback function to be executed before all tests.
+ * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+ * @returns {void}
+ * @example
+ * ```ts
+ * // Example of using beforeAll to set up a database connection
+ * beforeAll(async () => {
+ *   await database.connect();
+ * });
+ * ```
+ */
+declare function beforeAll(fn: BeforeAllListener, timeout?: number): void;
+/**
+ * Registers a callback function to be executed once after all tests within the current suite have completed.
+ * This hook is useful for scenarios where you need to perform cleanup operations after all tests in a suite have run, such as closing database connections or cleaning up temporary files.
+ *
+ * **Note:** The `afterAll` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+ *
+ * @param {Function} fn - The callback function to be executed after all tests.
+ * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+ * @returns {void}
+ * @example
+ * ```ts
+ * // Example of using afterAll to close a database connection
+ * afterAll(async () => {
+ *   await database.disconnect();
+ * });
+ * ```
+ */
+declare function afterAll(fn: AfterAllListener, timeout?: number): void;
+/**
+ * Registers a callback function to be executed before each test within the current suite.
+ * This hook is useful for scenarios where you need to reset or reinitialize the test environment before each test runs, such as resetting database states, clearing caches, or reinitializing variables.
+ *
+ * **Note:** The `beforeEach` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
+ *
+ * @param {Function} fn - The callback function to be executed before each test. This function receives an `TestContext` parameter if additional test context is needed.
+ * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+ * @returns {void}
+ * @example
+ * ```ts
+ * // Example of using beforeEach to reset a database state
+ * beforeEach(async () => {
+ *   await database.reset();
+ * });
+ * ```
+ */
+declare function beforeEach<ExtraContext = object>(fn: BeforeEachListener<ExtraContext>, timeout?: number): void;
+/**
+ * Registers a callback function to be executed after each test within the current suite has completed.
+ * This hook is useful for scenarios where you need to clean up or reset the test environment after each test runs, such as deleting temporary files, clearing test-specific database entries, or resetting mocked functions.
+ *
+ * **Note:** The `afterEach` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+ *
+ * @param {Function} fn - The callback function to be executed after each test. This function receives an `TestContext` parameter if additional test context is needed.
+ * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+ * @returns {void}
+ * @example
+ * ```ts
+ * // Example of using afterEach to delete temporary files created during a test
+ * afterEach(async () => {
+ *   await fileSystem.deleteTempFiles();
+ * });
+ * ```
+ */
+declare function afterEach<ExtraContext = object>(fn: AfterEachListener<ExtraContext>, timeout?: number): void;
+/**
+ * Registers a callback function to be executed when a test fails within the current suite.
+ * This function allows for custom actions to be performed in response to test failures, such as logging, cleanup, or additional diagnostics.
+ *
+ * **Note:** The `onTestFailed` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+ *
+ * @param {Function} fn - The callback function to be executed upon a test failure. The function receives the test result (including errors).
+ * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+ * @throws {Error} Throws an error if the function is not called within a test.
+ * @returns {void}
+ * @example
+ * ```ts
+ * // Example of using onTestFailed to log failure details
+ * onTestFailed(({ errors }) => {
+ *   console.log(`Test failed: ${test.name}`, errors);
+ * });
+ * ```
+ */
+declare const onTestFailed: TaskHook<OnTestFailedHandler>;
+/**
+ * Registers a callback function to be executed when the current test finishes, regardless of the outcome (pass or fail).
+ * This function is ideal for performing actions that should occur after every test execution, such as cleanup, logging, or resetting shared resources.
+ *
+ * This hook is useful if you have access to a resource in the test itself and you want to clean it up after the test finishes. It is a more compact way to clean up resources than using the combination of `beforeEach` and `afterEach`.
+ *
+ * **Note:** The `onTestFinished` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+ *
+ * @param {Function} fn - The callback function to be executed after a test finishes. The function can receive parameters providing details about the completed test, including its success or failure status.
+ * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+ * @throws {Error} Throws an error if the function is not called within a test.
+ * @returns {void}
+ * @example
+ * ```ts
+ * // Example of using onTestFinished for cleanup
+ * const db = await connectToDatabase();
+ * onTestFinished(async () => {
+ *   await db.disconnect();
+ * });
+ * ```
+ */
+declare const onTestFinished: TaskHook<OnTestFinishedHandler>;
+
+declare function setFn(key: Test | Custom, fn: () => Awaitable<void>): void;
+declare function getFn<Task = Test | Custom>(key: Task): () => Awaitable<void>;
+declare function setHooks(key: Suite, hooks: SuiteHooks): void;
+declare function getHooks(key: Suite): SuiteHooks;
+
 declare function updateTask(task: Task, runner: VitestRunner): void;
 declare function startTests(paths: string[], runner: VitestRunner): Promise<File[]>;
 declare function publicCollect(paths: string[], runner: VitestRunner): Promise<File[]>;
@@ -133,127 +252,8 @@ declare const describe: SuiteAPI;
  */
 declare const it: TestAPI;
 declare function getCurrentSuite<ExtraContext = object>(): SuiteCollector<ExtraContext>;
-declare function createTaskCollector(fn: (...args: any[]) => any, context?: Record<string, unknown>): CustomAPI;
-
-/**
- * Registers a callback function to be executed once before all tests within the current suite.
- * This hook is useful for scenarios where you need to perform setup operations that are common to all tests in a suite, such as initializing a database connection or setting up a test environment.
- *
- * **Note:** The `beforeAll` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
- *
- * @param {Function} fn - The callback function to be executed before all tests.
- * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
- * @returns {void}
- * @example
- * ```ts
- * // Example of using beforeAll to set up a database connection
- * beforeAll(async () => {
- *   await database.connect();
- * });
- * ```
- */
-declare function beforeAll(fn: BeforeAllListener, timeout?: number): void;
-/**
- * Registers a callback function to be executed once after all tests within the current suite have completed.
- * This hook is useful for scenarios where you need to perform cleanup operations after all tests in a suite have run, such as closing database connections or cleaning up temporary files.
- *
- * **Note:** The `afterAll` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
- *
- * @param {Function} fn - The callback function to be executed after all tests.
- * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
- * @returns {void}
- * @example
- * ```ts
- * // Example of using afterAll to close a database connection
- * afterAll(async () => {
- *   await database.disconnect();
- * });
- * ```
- */
-declare function afterAll(fn: AfterAllListener, timeout?: number): void;
-/**
- * Registers a callback function to be executed before each test within the current suite.
- * This hook is useful for scenarios where you need to reset or reinitialize the test environment before each test runs, such as resetting database states, clearing caches, or reinitializing variables.
- *
- * **Note:** The `beforeEach` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
- *
- * @param {Function} fn - The callback function to be executed before each test. This function receives an `TestContext` parameter if additional test context is needed.
- * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
- * @returns {void}
- * @example
- * ```ts
- * // Example of using beforeEach to reset a database state
- * beforeEach(async () => {
- *   await database.reset();
- * });
- * ```
- */
-declare function beforeEach<ExtraContext = object>(fn: BeforeEachListener<ExtraContext>, timeout?: number): void;
-/**
- * Registers a callback function to be executed after each test within the current suite has completed.
- * This hook is useful for scenarios where you need to clean up or reset the test environment after each test runs, such as deleting temporary files, clearing test-specific database entries, or resetting mocked functions.
- *
- * **Note:** The `afterEach` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
- *
- * @param {Function} fn - The callback function to be executed after each test. This function receives an `TestContext` parameter if additional test context is needed.
- * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
- * @returns {void}
- * @example
- * ```ts
- * // Example of using afterEach to delete temporary files created during a test
- * afterEach(async () => {
- *   await fileSystem.deleteTempFiles();
- * });
- * ```
- */
-declare function afterEach<ExtraContext = object>(fn: AfterEachListener<ExtraContext>, timeout?: number): void;
-/**
- * Registers a callback function to be executed when a test fails within the current suite.
- * This function allows for custom actions to be performed in response to test failures, such as logging, cleanup, or additional diagnostics.
- *
- * **Note:** The `onTestFailed` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
- *
- * @param {Function} fn - The callback function to be executed upon a test failure. The function receives the test result (including errors).
- * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
- * @throws {Error} Throws an error if the function is not called within a test.
- * @returns {void}
- * @example
- * ```ts
- * // Example of using onTestFailed to log failure details
- * onTestFailed(({ errors }) => {
- *   console.log(`Test failed: ${test.name}`, errors);
- * });
- * ```
- */
-declare const onTestFailed: TaskHook<OnTestFailedHandler>;
-/**
- * Registers a callback function to be executed when the current test finishes, regardless of the outcome (pass or fail).
- * This function is ideal for performing actions that should occur after every test execution, such as cleanup, logging, or resetting shared resources.
- *
- * This hook is useful if you have access to a resource in the test itself and you want to clean it up after the test finishes. It is a more compact way to clean up resources than using the combination of `beforeEach` and `afterEach`.
- *
- * **Note:** The `onTestFinished` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
- *
- * @param {Function} fn - The callback function to be executed after a test finishes. The function can receive parameters providing details about the completed test, including its success or failure status.
- * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
- * @throws {Error} Throws an error if the function is not called within a test.
- * @returns {void}
- * @example
- * ```ts
- * // Example of using onTestFinished for cleanup
- * const db = await connectToDatabase();
- * onTestFinished(async () => {
- *   await db.disconnect();
- * });
- * ```
- */
-declare const onTestFinished: TaskHook<OnTestFinishedHandler>;
-
-declare function setFn(key: Test | Custom, fn: () => Awaitable<void>): void;
-declare function getFn<Task = Test | Custom>(key: Task): () => Awaitable<void>;
-declare function setHooks(key: Suite, hooks: SuiteHooks): void;
-declare function getHooks(key: Suite): SuiteHooks;
+declare function createTaskCollector(fn: (...args: any[]) => any, context?: Record<string, unknown>): TestAPI;
 
 declare function getCurrentTest<T extends Test | Custom | undefined>(): T;
 
-export { AfterAllListener, AfterEachListener, BeforeAllListener, BeforeEachListener, Custom, CustomAPI, File, OnTestFailedHandler, OnTestFinishedHandler, Suite, SuiteAPI, SuiteCollector, SuiteHooks, Task, TaskHook, Test, TestAPI, VitestRunner, afterAll, afterEach, beforeAll, beforeEach, publicCollect as collectTests, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, onTestFinished, setFn, setHooks, startTests, suite, test, updateTask };
+export { AfterAllListener, AfterEachListener, BeforeAllListener, BeforeEachListener, Custom, TestAPI as CustomAPI, File, OnTestFailedHandler, OnTestFinishedHandler, Suite, SuiteAPI, SuiteCollector, SuiteHooks, Task, TaskHook, Test, TestAPI, VitestRunner, afterAll, afterEach, beforeAll, beforeEach, publicCollect as collectTests, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, onTestFinished, setFn, setHooks, startTests, suite, test, updateTask };

package/dist/index.js

@@ -1,32 +1,10 @@
-import { getSafeTimers, isObject, createDefer, isNegativeNaN, format, objDisplay, objectAttr, toArray, shuffle, assertTypes } from '@vitest/utils';
+import { getSafeTimers, isObject, createDefer, isNegativeNaN, format, objDisplay, objectAttr, toArray, assertTypes, shuffle } from '@vitest/utils';
+import { parseSingleStack } from '@vitest/utils/source-map';
+import { c as createChainable, b as createFileTask, a as calculateSuiteHash, s as someTasksAreOnly, i as interpretTaskModes, l as limitConcurrency, p as partitionSuiteChildren, n as hasTests, m as hasFailed } from './chunk-tasks.js';
 import { processError } from '@vitest/utils/error';
 export { processError } from '@vitest/utils/error';
-import { l as createChainable, a as createFileTask, c as calculateSuiteHash, s as someTasksAreOnly, i as interpretTaskModes, m as limitConcurrency, p as partitionSuiteChildren, h as hasTests, j as hasFailed } from './chunk-tasks.js';
-import { parseSingleStack } from '@vitest/utils/source-map';
 import 'pathe';
 
-const fnMap = /* @__PURE__ */ new WeakMap();
-const fixtureMap = /* @__PURE__ */ new WeakMap();
-const hooksMap = /* @__PURE__ */ new WeakMap();
-function setFn(key, fn) {
-  fnMap.set(key, fn);
-}
-function getFn(key) {
-  return fnMap.get(key);
-}
-function setFixture(key, fixture) {
-  fixtureMap.set(key, fixture);
-}
-function getFixture(key) {
-  return fixtureMap.get(key);
-}
-function setHooks(key, hooks) {
-  hooksMap.set(key, hooks);
-}
-function getHooks(key) {
-  return hooksMap.get(key);
-}
-
 class PendingError extends Error {
   constructor(message, task) {
     super(message);
@@ -95,6 +73,28 @@ function makeTimeoutMsg(isHook, timeout) {
 If this is a long-running ${isHook ? "hook" : "test"}, pass a timeout value as the last argument or configure it globally with "${isHook ? "hookTimeout" : "testTimeout"}".`;
 }
 
+const fnMap = /* @__PURE__ */ new WeakMap();
+const fixtureMap = /* @__PURE__ */ new WeakMap();
+const hooksMap = /* @__PURE__ */ new WeakMap();
+function setFn(key, fn) {
+  fnMap.set(key, fn);
+}
+function getFn(key) {
+  return fnMap.get(key);
+}
+function setFixture(key, fixture) {
+  fixtureMap.set(key, fixture);
+}
+function getFixture(key) {
+  return fixtureMap.get(key);
+}
+function setHooks(key, hooks) {
+  hooksMap.set(key, hooks);
+}
+function getHooks(key) {
+  return hooksMap.get(key);
+}
+
 function mergeContextFixtures(fixtures, context = {}) {
   const fixtureOptionKeys = ["auto"];
   const fixtureArray = Object.entries(fixtures).map(
@@ -754,6 +754,66 @@ function findTestFileStackTrace(error, each) {
   }
 }
 
+function getDefaultHookTimeout() {
+  return getRunner().config.hookTimeout;
+}
+function beforeAll(fn, timeout) {
+  assertTypes(fn, '"beforeAll" callback', ["function"]);
+  return getCurrentSuite().on(
+    "beforeAll",
+    withTimeout(fn, timeout ?? getDefaultHookTimeout(), true)
+  );
+}
+function afterAll(fn, timeout) {
+  assertTypes(fn, '"afterAll" callback', ["function"]);
+  return getCurrentSuite().on(
+    "afterAll",
+    withTimeout(fn, timeout ?? getDefaultHookTimeout(), true)
+  );
+}
+function beforeEach(fn, timeout) {
+  assertTypes(fn, '"beforeEach" callback', ["function"]);
+  return getCurrentSuite().on(
+    "beforeEach",
+    withTimeout(withFixtures(fn), timeout ?? getDefaultHookTimeout(), true)
+  );
+}
+function afterEach(fn, timeout) {
+  assertTypes(fn, '"afterEach" callback', ["function"]);
+  return getCurrentSuite().on(
+    "afterEach",
+    withTimeout(withFixtures(fn), timeout ?? getDefaultHookTimeout(), true)
+  );
+}
+const onTestFailed = createTestHook(
+  "onTestFailed",
+  (test, handler, timeout) => {
+    test.onFailed || (test.onFailed = []);
+    test.onFailed.push(
+      withTimeout(handler, timeout ?? getDefaultHookTimeout(), true)
+    );
+  }
+);
+const onTestFinished = createTestHook(
+  "onTestFinished",
+  (test, handler, timeout) => {
+    test.onFinished || (test.onFinished = []);
+    test.onFinished.push(
+      withTimeout(handler, timeout ?? getDefaultHookTimeout(), true)
+    );
+  }
+);
+function createTestHook(name, handler) {
+  return (fn, timeout) => {
+    assertTypes(fn, `"${name}" callback`, ["function"]);
+    const current = getCurrentTest();
+    if (!current) {
+      throw new Error(`Hook ${name}() can only be called inside a test`);
+    }
+    return handler(current, fn, timeout);
+  };
+}
+
 async function runSetupFiles(config, files, runner) {
   if (config.sequence.setupFiles === "parallel") {
     await Promise.all(
@@ -864,15 +924,23 @@ function getSuiteHooks(suite, name, sequence) {
   }
   return hooks;
 }
-async function callTaskHooks(task, hooks, sequence) {
+async function callTestHooks(runner, task, hooks, sequence) {
   if (sequence === "stack") {
     hooks = hooks.slice().reverse();
   }
   if (sequence === "parallel") {
-    await Promise.all(hooks.map((fn) => fn(task.result)));
+    try {
+      await Promise.all(hooks.map((fn) => fn(task.result)));
+    } catch (e) {
+      failTask(task.result, e, runner.config.diffOptions);
+    }
   } else {
     for (const fn of hooks) {
-      await fn(task.result);
+      try {
+        await fn(task.result);
+      } catch (e) {
+        failTask(task.result, e, runner.config.diffOptions);
+      }
     }
   }
 }
@@ -1023,21 +1091,14 @@ async function runTest(test, runner) {
       } catch (e) {
         failTask(test.result, e, runner.config.diffOptions);
       }
-      try {
-        await callTaskHooks(test, test.onFinished || [], "stack");
-      } catch (e) {
-        failTask(test.result, e, runner.config.diffOptions);
-      }
+      await callTestHooks(runner, test, test.onFinished || [], "stack");
       if (test.result.state === "fail") {
-        try {
-          await callTaskHooks(
-            test,
-            test.onFailed || [],
-            runner.config.sequence.hooks
-          );
-        } catch (e) {
-          failTask(test.result, e, runner.config.diffOptions);
-        }
+        await callTestHooks(
+          runner,
+          test,
+          test.onFailed || [],
+          runner.config.sequence.hooks
+        );
       }
       delete test.onFailed;
       delete test.onFinished;
@@ -1220,64 +1281,4 @@ async function publicCollect(paths, runner) {
   return files;
 }
 
-function getDefaultHookTimeout() {
-  return getRunner().config.hookTimeout;
-}
-function beforeAll(fn, timeout) {
-  assertTypes(fn, '"beforeAll" callback', ["function"]);
-  return getCurrentSuite().on(
-    "beforeAll",
-    withTimeout(fn, timeout ?? getDefaultHookTimeout(), true)
-  );
-}
-function afterAll(fn, timeout) {
-  assertTypes(fn, '"afterAll" callback', ["function"]);
-  return getCurrentSuite().on(
-    "afterAll",
-    withTimeout(fn, timeout ?? getDefaultHookTimeout(), true)
-  );
-}
-function beforeEach(fn, timeout) {
-  assertTypes(fn, '"beforeEach" callback', ["function"]);
-  return getCurrentSuite().on(
-    "beforeEach",
-    withTimeout(withFixtures(fn), timeout ?? getDefaultHookTimeout(), true)
-  );
-}
-function afterEach(fn, timeout) {
-  assertTypes(fn, '"afterEach" callback', ["function"]);
-  return getCurrentSuite().on(
-    "afterEach",
-    withTimeout(withFixtures(fn), timeout ?? getDefaultHookTimeout(), true)
-  );
-}
-const onTestFailed = createTestHook(
-  "onTestFailed",
-  (test, handler, timeout) => {
-    test.onFailed || (test.onFailed = []);
-    test.onFailed.push(
-      withTimeout(handler, timeout ?? getDefaultHookTimeout(), true)
-    );
-  }
-);
-const onTestFinished = createTestHook(
-  "onTestFinished",
-  (test, handler, timeout) => {
-    test.onFinished || (test.onFinished = []);
-    test.onFinished.push(
-      withTimeout(handler, timeout ?? getDefaultHookTimeout(), true)
-    );
-  }
-);
-function createTestHook(name, handler) {
-  return (fn, timeout) => {
-    assertTypes(fn, `"${name}" callback`, ["function"]);
-    const current = getCurrentTest();
-    if (!current) {
-      throw new Error(`Hook ${name}() can only be called inside a test`);
-    }
-    return handler(current, fn, timeout);
-  };
-}
-
 export { afterAll, afterEach, beforeAll, beforeEach, publicCollect as collectTests, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, onTestFinished, setFn, setHooks, startTests, suite, test, updateTask };

package/dist/{tasks-SNKRxoD7.d.ts → tasks-3ZnPj1LR.d.ts}

@@ -1,12 +1,5 @@
 import { ErrorWithDiff, Awaitable } from '@vitest/utils';
 
-type ChainableFunction<T extends string, F extends (...args: any) => any, C = object> = F & {
-    [x in T]: ChainableFunction<T, F, C>;
-} & {
-    fn: (this: Record<T, any>, ...args: Parameters<F>) => ReturnType<F>;
-} & C;
-declare function createChainable<T extends string, Args extends any[], R = any>(keys: T[], fn: (this: Record<T, any>, ...args: Args) => R): ChainableFunction<T, (...args: Args) => R>;
-
 interface FixtureItem extends FixtureOptions {
     prop: string;
     value: any;
@@ -20,6 +13,13 @@ interface FixtureItem extends FixtureOptions {
     deps?: FixtureItem[];
 }
 
+type ChainableFunction<T extends string, F extends (...args: any) => any, C = object> = F & {
+    [x in T]: ChainableFunction<T, F, C>;
+} & {
+    fn: (this: Record<T, any>, ...args: Parameters<F>) => ReturnType<F>;
+} & C;
+declare function createChainable<T extends string, Args extends any[], R = any>(keys: T[], fn: (this: Record<T, any>, ...args: Args) => R): ChainableFunction<T, (...args: Args) => R>;
+
 type RunMode = 'run' | 'skip' | 'only' | 'todo';
 type TaskState = RunMode | 'pass' | 'fail';
 interface TaskBase {
@@ -335,12 +335,12 @@ interface ExtendedAPI<ExtraContext> {
     skipIf: (condition: any) => ChainableTestAPI<ExtraContext>;
     runIf: (condition: any) => ChainableTestAPI<ExtraContext>;
 }
-type CustomAPI<ExtraContext = object> = ChainableTestAPI<ExtraContext> & ExtendedAPI<ExtraContext> & {
-    extend: <T extends Record<string, any> = object>(fixtures: Fixtures<T, ExtraContext>) => CustomAPI<{
+type TestAPI<ExtraContext = object> = ChainableTestAPI<ExtraContext> & ExtendedAPI<ExtraContext> & {
+    extend: <T extends Record<string, any> = object>(fixtures: Fixtures<T, ExtraContext>) => TestAPI<{
         [K in keyof T | keyof ExtraContext]: K extends keyof T ? T[K] : K extends keyof ExtraContext ? ExtraContext[K] : never;
     }>;
 };
-type TestAPI<ExtraContext = object> = CustomAPI<ExtraContext>;
+
 interface FixtureOptions {
     /**
      * Whether to automatically set up current fixture, even though it's not being used in tests.
@@ -468,4 +468,4 @@ interface TaskHook<HookListener> {
 type SequenceHooks = 'stack' | 'list' | 'parallel';
 type SequenceSetupFiles = 'list' | 'parallel';
 
-export { type AfterAllListener as A, type BeforeAllListener as B, type Custom as C, type DoneCallback as D, type SuiteFactory as E, type File as F, type RuntimeContext as G, type HookListener as H, type InferFixturesTypes as I, type TestContext as J, type TaskContext as K, type ExtendedContext as L, type SequenceHooks as M, type SequenceSetupFiles as N, type OnTestFailedHandler as O, type RunMode as R, type Suite as S, type Task as T, type Use as U, type Test as a, type ChainableFunction as b, createChainable as c, type SuiteAPI as d, type TestAPI as e, type SuiteCollector as f, type CustomAPI as g, type BeforeEachListener as h, type AfterEachListener as i, type TaskHook as j, type OnTestFinishedHandler as k, type SuiteHooks as l, type TaskState as m, type TaskBase as n, type TaskPopulated as o, type TaskMeta as p, type TaskResult as q, type TaskResultPack as r, type TestFunction as s, type TestOptions as t, type FixtureOptions as u, type FixtureFn as v, type Fixture as w, type Fixtures as x, type HookCleanupCallback as y, type TaskCustomOptions as z };
+export { type AfterAllListener as A, type BeforeAllListener as B, type Custom as C, type DoneCallback as D, type ExtendedContext as E, type File as F, type TaskResultPack as G, type HookCleanupCallback as H, type InferFixturesTypes as I, type TaskState as J, type TestContext as K, type TestFunction as L, type TestOptions as M, type OnTestFailedHandler as O, type RunMode as R, type Suite as S, type Task as T, type Use as U, type Test as a, type ChainableFunction as b, createChainable as c, type BeforeEachListener as d, type AfterEachListener as e, type TaskHook as f, type OnTestFinishedHandler as g, type SuiteHooks as h, type SuiteAPI as i, type TestAPI as j, type SuiteCollector as k, type Fixture as l, type FixtureFn as m, type FixtureOptions as n, type Fixtures as o, type HookListener as p, type RuntimeContext as q, type SequenceHooks as r, type SequenceSetupFiles as s, type SuiteFactory as t, type TaskBase as u, type TaskContext as v, type TaskCustomOptions as w, type TaskMeta as x, type TaskPopulated as y, type TaskResult as z };

package/dist/types.d.ts

@@ -1,6 +1,6 @@
-import { M as SequenceHooks, N as SequenceSetupFiles, F as File, T as Task, a as Test, C as Custom, S as Suite, r as TaskResultPack, K as TaskContext, L as ExtendedContext } from './tasks-SNKRxoD7.js';
-export { A as AfterAllListener, i as AfterEachListener, B as BeforeAllListener, h as BeforeEachListener, g as CustomAPI, D as DoneCallback, w as Fixture, v as FixtureFn, u as FixtureOptions, x as Fixtures, y as HookCleanupCallback, H as HookListener, I as InferFixturesTypes, O as OnTestFailedHandler, k as OnTestFinishedHandler, R as RunMode, G as RuntimeContext, d as SuiteAPI, f as SuiteCollector, E as SuiteFactory, l as SuiteHooks, n as TaskBase, z as TaskCustomOptions, j as TaskHook, p as TaskMeta, o as TaskPopulated, q as TaskResult, m as TaskState, e as TestAPI, J as TestContext, s as TestFunction, t as TestOptions, U as Use } from './tasks-SNKRxoD7.js';
 import { DiffOptions } from '@vitest/utils/diff';
+import { r as SequenceHooks, s as SequenceSetupFiles, F as File, T as Task, a as Test, C as Custom, S as Suite, G as TaskResultPack, v as TaskContext, E as ExtendedContext } from './tasks-3ZnPj1LR.js';
+export { A as AfterAllListener, e as AfterEachListener, B as BeforeAllListener, d as BeforeEachListener, j as CustomAPI, D as DoneCallback, l as Fixture, m as FixtureFn, n as FixtureOptions, o as Fixtures, H as HookCleanupCallback, p as HookListener, I as InferFixturesTypes, O as OnTestFailedHandler, g as OnTestFinishedHandler, R as RunMode, q as RuntimeContext, i as SuiteAPI, k as SuiteCollector, t as SuiteFactory, h as SuiteHooks, u as TaskBase, w as TaskCustomOptions, f as TaskHook, x as TaskMeta, y as TaskPopulated, z as TaskResult, J as TaskState, j as TestAPI, K as TestContext, L as TestFunction, M as TestOptions, U as Use } from './tasks-3ZnPj1LR.js';
 import '@vitest/utils';
 
 /**

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { S as Suite, F as File, T as Task, a as Test, C as Custom } from './tasks-SNKRxoD7.js';
-export { b as ChainableFunction, c as createChainable } from './tasks-SNKRxoD7.js';
+import { S as Suite, F as File, T as Task, a as Test, C as Custom } from './tasks-3ZnPj1LR.js';
+export { b as ChainableFunction, c as createChainable } from './tasks-3ZnPj1LR.js';
 import { Arrayable } from '@vitest/utils';
 
 /**
@@ -11,6 +11,11 @@ declare function generateHash(str: string): string;
 declare function calculateSuiteHash(parent: Suite): void;
 declare function createFileTask(filepath: string, root: string, projectName: string | undefined, pool?: string): File;
 
+/**
+ * Return a function for running multiple async operations with limited concurrency.
+ */
+declare function limitConcurrency(concurrency?: number): <Args extends unknown[], T>(func: (...args: Args) => PromiseLike<T> | T, ...args: Args) => Promise<T>;
+
 /**
  * Partition in tasks groups by consecutive concurrent
  */
@@ -23,10 +28,7 @@ declare function getSuites(suite: Arrayable<Task>): Suite[];
 declare function hasTests(suite: Arrayable<Suite>): boolean;
 declare function hasFailed(suite: Arrayable<Task>): boolean;
 declare function getNames(task: Task): string[];
+declare function getFullName(task: Task, separator?: string): string;
+declare function getTestName(task: Task, separator?: string): string;
 
-/**
- * Return a function for running multiple async operations with limited concurrency.
- */
-declare function limitConcurrency(concurrency?: number): <Args extends unknown[], T>(func: (...args: Args) => PromiseLike<T> | T, ...args: Args) => Promise<T>;
-
-export { calculateSuiteHash, createFileTask, generateHash, getNames, getSuites, getTasks, getTests, hasFailed, hasTests, interpretTaskModes, isAtomTest, limitConcurrency, partitionSuiteChildren, someTasksAreOnly };
+export { calculateSuiteHash, createFileTask, generateHash, getFullName, getNames, getSuites, getTasks, getTestName, getTests, hasFailed, hasTests, interpretTaskModes, isAtomTest, limitConcurrency, partitionSuiteChildren, someTasksAreOnly };

package/dist/utils.js

@@ -1,4 +1,4 @@
-export { c as calculateSuiteHash, l as createChainable, a as createFileTask, g as generateHash, k as getNames, f as getSuites, e as getTasks, d as getTests, j as hasFailed, h as hasTests, i as interpretTaskModes, b as isAtomTest, m as limitConcurrency, p as partitionSuiteChildren, s as someTasksAreOnly } from './chunk-tasks.js';
+export { a as calculateSuiteHash, c as createChainable, b as createFileTask, g as generateHash, d as getFullName, e as getNames, f as getSuites, h as getTasks, j as getTestName, k as getTests, m as hasFailed, n as hasTests, i as interpretTaskModes, o as isAtomTest, l as limitConcurrency, p as partitionSuiteChildren, s as someTasksAreOnly } from './chunk-tasks.js';
 import '@vitest/utils/error';
 import 'pathe';
 import '@vitest/utils';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/runner",
   "type": "module",
-  "version": "2.1.3",
+  "version": "2.1.5",
   "description": "Vitest test runner",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -39,7 +39,7 @@
   ],
   "dependencies": {
     "pathe": "^1.1.2",
-    "@vitest/utils": "2.1.3"
+    "@vitest/utils": "2.1.5"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",