@vitest/runner 2.2.0-beta.1 → 3.0.0-beta.1

package/dist/chunk-tasks.js

@@ -29,39 +29,67 @@ function createChainable(keys, fn) {
   return chain;
 }
 
-function interpretTaskModes(suite, namePattern, onlyMode, parentIsOnly, allowOnly) {
-  const suiteIsOnly = parentIsOnly || suite.mode === "only";
-  suite.tasks.forEach((t) => {
-    const includeTask = suiteIsOnly || t.mode === "only";
-    if (onlyMode) {
-      if (t.type === "suite" && (includeTask || someTasksAreOnly(t))) {
-        if (t.mode === "only") {
+function interpretTaskModes(file, namePattern, testLocations, onlyMode, parentIsOnly, allowOnly) {
+  const matchedLocations = [];
+  const traverseSuite = (suite, parentIsOnly2) => {
+    const suiteIsOnly = parentIsOnly2 || suite.mode === "only";
+    suite.tasks.forEach((t) => {
+      const includeTask = suiteIsOnly || t.mode === "only";
+      if (onlyMode) {
+        if (t.type === "suite" && (includeTask || someTasksAreOnly(t))) {
+          if (t.mode === "only") {
+            checkAllowOnly(t, allowOnly);
+            t.mode = "run";
+          }
+        } else if (t.mode === "run" && !includeTask) {
+          t.mode = "skip";
+        } else if (t.mode === "only") {
           checkAllowOnly(t, allowOnly);
           t.mode = "run";
         }
-      } else if (t.mode === "run" && !includeTask) {
-        t.mode = "skip";
-      } else if (t.mode === "only") {
-        checkAllowOnly(t, allowOnly);
-        t.mode = "run";
       }
-    }
-    if (t.type === "test") {
-      if (namePattern && !getTaskFullName(t).match(namePattern)) {
-        t.mode = "skip";
+      if (t.type === "test") {
+        if (namePattern && !getTaskFullName(t).match(namePattern)) {
+          t.mode = "skip";
+        }
+        if (testLocations !== void 0 && testLocations.length !== 0) {
+          if (t.location && (testLocations == null ? void 0 : testLocations.includes(t.location.line))) {
+            t.mode = "run";
+            matchedLocations.push(t.location.line);
+          } else {
+            t.mode = "skip";
+          }
+        }
+      } else if (t.type === "suite") {
+        if (t.mode === "skip") {
+          skipAllTasks(t);
+        } else {
+          traverseSuite(t, includeTask);
+        }
       }
-    } else if (t.type === "suite") {
-      if (t.mode === "skip") {
-        skipAllTasks(t);
-      } else {
-        interpretTaskModes(t, namePattern, onlyMode, includeTask, allowOnly);
+    });
+    if (suite.mode === "run") {
+      if (suite.tasks.length && suite.tasks.every((i) => i.mode !== "run")) {
+        suite.mode = "skip";
       }
     }
-  });
-  if (suite.mode === "run") {
-    if (suite.tasks.length && suite.tasks.every((i) => i.mode !== "run")) {
-      suite.mode = "skip";
+  };
+  traverseSuite(file, parentIsOnly);
+  const nonMatching = testLocations == null ? void 0 : testLocations.filter((loc) => !matchedLocations.includes(loc));
+  if (nonMatching && nonMatching.length !== 0) {
+    const message = nonMatching.length === 1 ? `line ${nonMatching[0]}` : `lines ${nonMatching.join(", ")}`;
+    if (file.result === void 0) {
+      file.result = {
+        state: "fail",
+        errors: []
+      };
+    }
+    if (file.result.errors === void 0) {
+      file.result.errors = [];
     }
+    file.result.errors.push(
+      processError(new Error(`No test found in ${file.name} in ${message}`))
+    );
   }
 }
 function getTaskFullName(task) {
@@ -179,17 +207,20 @@ function partitionSuiteChildren(suite) {
 }
 
 function isAtomTest(s) {
-  return s.type === "test" || s.type === "custom";
+  return isTestCase(s);
+}
+function isTestCase(s) {
+  return s.type === "test";
 }
 function getTests(suite) {
   const tests = [];
   const arraySuites = toArray(suite);
   for (const s of arraySuites) {
-    if (isAtomTest(s)) {
+    if (isTestCase(s)) {
       tests.push(s);
     } else {
       for (const task of s.tasks) {
-        if (isAtomTest(task)) {
+        if (isTestCase(task)) {
           tests.push(task);
         } else {
           const taskTests = getTests(task);
@@ -204,7 +235,7 @@ function getTests(suite) {
 }
 function getTasks(tasks = []) {
   return toArray(tasks).flatMap(
-    (s) => isAtomTest(s) ? [s] : [s, ...getTasks(s.tasks)]
+    (s) => isTestCase(s) ? [s] : [s, ...getTasks(s.tasks)]
   );
 }
 function getSuites(suite) {
@@ -214,7 +245,7 @@ function getSuites(suite) {
 }
 function hasTests(suite) {
   return toArray(suite).some(
-    (s) => s.tasks.some((c) => isAtomTest(c) || hasTests(c))
+    (s) => s.tasks.some((c) => isTestCase(c) || hasTests(c))
   );
 }
 function hasFailed(suite) {
@@ -246,4 +277,4 @@ function getTestName(task, separator = " > ") {
   return getNames(task).slice(1).join(separator);
 }
 
-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 };
+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, isTestCase as q, someTasksAreOnly as s };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-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-F_411-nA.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-F_411-nA.js';
+import { B as BeforeAllListener, A as AfterAllListener, b as BeforeEachListener, d as AfterEachListener, e as TaskHook, O as OnTestFailedHandler, f as OnTestFinishedHandler, a as Test, g 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-D_Ah6OyC.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-D_Ah6OyC.js';
 import { Awaitable } from '@vitest/utils';
-import { VitestRunner } from './types.js';
+import { VitestRunner, FileSpec } from './types.js';
 export { CancelReason, VitestRunnerConfig, VitestRunnerConstructor, VitestRunnerImportSource } from './types.js';
 export { processError } from '@vitest/utils/error';
 import '@vitest/utils/diff';
@@ -126,8 +126,8 @@ 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[]>;
+declare function startTests(specs: string[] | FileSpec[], runner: VitestRunner): Promise<File[]>;
+declare function publicCollect(specs: string[] | FileSpec[], runner: VitestRunner): Promise<File[]>;
 
 /**
  * Creates a suite of tests, allowing for grouping and hierarchical organization of tests.
@@ -254,6 +254,6 @@ declare const it: TestAPI;
 declare function getCurrentSuite<ExtraContext = object>(): SuiteCollector<ExtraContext>;
 declare function createTaskCollector(fn: (...args: any[]) => any, context?: Record<string, unknown>): TestAPI;
 
-declare function getCurrentTest<T extends Test | Custom | undefined>(): T;
+declare function getCurrentTest<T extends Test | undefined>(): T;
 
-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 };
+export { AfterAllListener, AfterEachListener, BeforeAllListener, BeforeEachListener, Custom, TestAPI as CustomAPI, File, FileSpec, 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

@@ -59,13 +59,17 @@ function createTestContext(test, runner) {
     test.pending = true;
     throw new PendingError("test is skipped; abort execution", test, note);
   };
-  context.onTestFailed = (fn) => {
+  context.onTestFailed = (handler, timeout) => {
     test.onFailed || (test.onFailed = []);
-    test.onFailed.push(fn);
+    test.onFailed.push(
+      withTimeout(handler, timeout ?? runner.config.hookTimeout, true)
+    );
   };
-  context.onTestFinished = (fn) => {
+  context.onTestFinished = (handler, timeout) => {
     test.onFinished || (test.onFinished = []);
-    test.onFinished.push(fn);
+    test.onFinished.push(
+      withTimeout(handler, timeout ?? runner.config.hookTimeout, true)
+    );
   };
   return ((_a = runner.extendTaskContext) == null ? void 0 : _a.call(runner, context)) || context;
 }
@@ -331,8 +335,7 @@ function getRunner() {
 }
 function createDefaultSuite(runner2) {
   const config = runner2.config.sequence;
-  const api = config.shuffle ? suite.shuffle : suite;
-  return api("", { concurrent: config.concurrent }, () => {
+  return suite("", { concurrent: config.concurrent }, () => {
   });
 }
 function clearCollectorContext(filepath, currentRunner) {
@@ -368,6 +371,9 @@ function parseArguments(optionsOrFn, optionsOrTest) {
         "Cannot use two objects as arguments. Please provide options and a function callback in that order."
       );
     }
+    console.warn(
+      "Using an object as a third argument is deprecated. Vitest 4 will throw an error if the third argument is not a timeout number. Please use the second argument for options. See more at https://vitest.dev/guide/migration"
+    );
     options = optionsOrTest;
   } else if (typeof optionsOrTest === "number") {
     options = { timeout: optionsOrTest };
@@ -390,7 +396,7 @@ function parseArguments(optionsOrFn, optionsOrTest) {
   };
 }
 function createSuiteCollector(name, factory = () => {
-}, mode, shuffle, each, suiteOptions) {
+}, mode, each, suiteOptions) {
   const tasks = [];
   const factoryQueue = [];
   let suite2;
@@ -403,7 +409,7 @@ function createSuiteCollector(name, factory = () => {
       each: options.each,
       fails: options.fails,
       context: void 0,
-      type: "custom",
+      type: "test",
       file: void 0,
       retry: options.retry ?? runner.config.retry,
       repeats: options.repeats,
@@ -414,9 +420,7 @@ function createSuiteCollector(name, factory = () => {
     if (options.concurrent || !options.sequential && runner.config.sequence.concurrent) {
       task2.concurrent = true;
     }
-    if (shuffle) {
-      task2.shuffle = true;
-    }
+    task2.shuffle = suiteOptions == null ? void 0 : suiteOptions.shuffle;
     const context = createTestContext(task2, runner);
     Object.defineProperty(task2, "context", {
       value: context,
@@ -485,7 +489,7 @@ function createSuiteCollector(name, factory = () => {
       mode,
       each,
       file: void 0,
-      shuffle,
+      shuffle: suiteOptions == null ? void 0 : suiteOptions.shuffle,
       tasks: [],
       meta: /* @__PURE__ */ Object.create(null),
       concurrent: suiteOptions == null ? void 0 : suiteOptions.concurrent
@@ -543,7 +547,8 @@ function withAwaitAsyncAssetions(fn, task) {
   };
 }
 function createSuite() {
-  function suiteFn(name, factoryOrOptions, optionsOrFactory = {}) {
+  function suiteFn(name, factoryOrOptions, optionsOrFactory) {
+    var _a;
     const mode = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
     const currentSuite = collectorContext.currentSuite || defaultSuite;
     let { options, handler: factory } = parseArguments(
@@ -552,9 +557,11 @@ function createSuite() {
     );
     const isConcurrentSpecified = options.concurrent || this.concurrent || options.sequential === false;
     const isSequentialSpecified = options.sequential || this.sequential || options.concurrent === false;
-    if (currentSuite == null ? void 0 : currentSuite.options) {
-      options = { ...currentSuite.options, ...options };
-    }
+    options = {
+      ...currentSuite == null ? void 0 : currentSuite.options,
+      ...options,
+      shuffle: this.shuffle ?? options.shuffle ?? ((_a = currentSuite == null ? void 0 : currentSuite.options) == null ? void 0 : _a.shuffle) ?? (runner == null ? void 0 : runner.config.sequence.shuffle)
+    };
     const isConcurrent = isConcurrentSpecified || options.concurrent && !isSequentialSpecified;
     const isSequential = isSequentialSpecified || options.sequential && !isConcurrentSpecified;
     options.concurrent = isConcurrent && !isSequential;
@@ -563,7 +570,6 @@ function createSuite() {
       formatName(name),
       factory,
       mode,
-      this.shuffle,
       this.each,
       options
     );
@@ -578,7 +584,7 @@ function createSuite() {
       const _name = formatName(name);
       const arrayOnlyCases = cases.every(Array.isArray);
       const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
-      const fnFirst = typeof optionsOrFn === "function";
+      const fnFirst = typeof optionsOrFn === "function" && typeof fnOrOptions === "object";
       cases.forEach((i, idx) => {
         const items = Array.isArray(i) ? i : [i];
         if (fnFirst) {
@@ -621,7 +627,7 @@ function createTaskCollector(fn, context) {
       const _name = formatName(name);
       const arrayOnlyCases = cases.every(Array.isArray);
       const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
-      const fnFirst = typeof optionsOrFn === "function";
+      const fnFirst = typeof optionsOrFn === "function" && typeof fnOrOptions === "object";
       cases.forEach((i, idx) => {
         const items = Array.isArray(i) ? i : [i];
         if (fnFirst) {
@@ -838,12 +844,15 @@ async function runSetupFiles(config, files, runner) {
 }
 
 const now$1 = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
-async function collectTests(paths, runner) {
+async function collectTests(specs, runner) {
   var _a;
   const files = [];
   const config = runner.config;
-  for (const filepath of paths) {
+  for (const spec of specs) {
+    const filepath = typeof spec === "string" ? spec : spec.filepath;
+    const testLocations = typeof spec === "string" ? void 0 : spec.testLocations;
     const file = createFileTask(filepath, config.root, config.name, runner.pool);
+    file.shuffle = config.sequence.shuffle;
     (_a = runner.onCollectStart) == null ? void 0 : _a.call(runner, file);
     clearCollectorContext(filepath, runner);
     try {
@@ -862,7 +871,7 @@ async function collectTests(paths, runner) {
       const fileHooks = createSuiteHooks();
       mergeHooks(fileHooks, getHooks(defaultTasks));
       for (const c of [...defaultTasks.tasks, ...collectorContext.tasks]) {
-        if (c.type === "test" || c.type === "custom" || c.type === "suite") {
+        if (c.type === "test" || c.type === "suite") {
           file.tasks.push(c);
         } else if (c.type === "collector") {
           const suite = await c.collect(file);
@@ -894,6 +903,7 @@ async function collectTests(paths, runner) {
     interpretTaskModes(
       file,
       config.testNamePattern,
+      testLocations,
       hasOnlyTasks,
       false,
       config.allowOnly
@@ -933,25 +943,38 @@ function getSuiteHooks(suite, name, sequence) {
   }
   return hooks;
 }
-async function callTestHooks(runner, task, hooks, sequence) {
+async function callTestHooks(runner, test, hooks, sequence) {
   if (sequence === "stack") {
     hooks = hooks.slice().reverse();
   }
+  if (!hooks.length) {
+    return;
+  }
+  const onTestFailed = test.context.onTestFailed;
+  const onTestFinished = test.context.onTestFinished;
+  test.context.onTestFailed = () => {
+    throw new Error(`Cannot call "onTestFailed" inside a test hook.`);
+  };
+  test.context.onTestFinished = () => {
+    throw new Error(`Cannot call "onTestFinished" inside a test hook.`);
+  };
   if (sequence === "parallel") {
     try {
-      await Promise.all(hooks.map((fn) => fn(task.result)));
+      await Promise.all(hooks.map((fn) => fn(test.context)));
     } catch (e) {
-      failTask(task.result, e, runner.config.diffOptions);
+      failTask(test.result, e, runner.config.diffOptions);
     }
   } else {
     for (const fn of hooks) {
       try {
-        await fn(task.result);
+        await fn(test.context);
       } catch (e) {
-        failTask(task.result, e, runner.config.diffOptions);
+        failTask(test.result, e, runner.config.diffOptions);
       }
     }
   }
+  test.context.onTestFailed = onTestFailed;
+  test.context.onTestFinished = onTestFinished;
 }
 async function callSuiteHook(suite, currentTask, name, runner, args) {
   const sequence = runner.config.sequence.hooks;
@@ -1201,7 +1224,7 @@ async function runSuite(suite, runner) {
             await Promise.all(tasksGroup.map((c) => runSuiteChild(c, runner)));
           } else {
             const { sequence } = runner.config;
-            if (sequence.shuffle || suite.shuffle) {
+            if (suite.shuffle) {
               const suites = tasksGroup.filter(
                 (group) => group.type === "suite"
               );
@@ -1248,7 +1271,7 @@ async function runSuite(suite, runner) {
 }
 let limitMaxConcurrency;
 async function runSuiteChild(c, runner) {
-  if (c.type === "test" || c.type === "custom") {
+  if (c.type === "test") {
     return limitMaxConcurrency(() => runTest(c, runner));
   } else if (c.type === "suite") {
     return runSuite(c, runner);
@@ -1272,10 +1295,11 @@ async function runFiles(files, runner) {
     await runSuite(file, runner);
   }
 }
-async function startTests(paths, runner) {
+async function startTests(specs, runner) {
   var _a, _b, _c, _d;
+  const paths = specs.map((f) => typeof f === "string" ? f : f.filepath);
   await ((_a = runner.onBeforeCollect) == null ? void 0 : _a.call(runner, paths));
-  const files = await collectTests(paths, runner);
+  const files = await collectTests(specs, runner);
   await ((_b = runner.onCollected) == null ? void 0 : _b.call(runner, files));
   await ((_c = runner.onBeforeRunFiles) == null ? void 0 : _c.call(runner, files));
   await runFiles(files, runner);
@@ -1283,10 +1307,11 @@ async function startTests(paths, runner) {
   await sendTasksUpdate(runner);
   return files;
 }
-async function publicCollect(paths, runner) {
+async function publicCollect(specs, runner) {
   var _a, _b;
+  const paths = specs.map((f) => typeof f === "string" ? f : f.filepath);
   await ((_a = runner.onBeforeCollect) == null ? void 0 : _a.call(runner, paths));
-  const files = await collectTests(paths, runner);
+  const files = await collectTests(specs, runner);
   await ((_b = runner.onCollected) == null ? void 0 : _b.call(runner, files));
   return files;
 }

package/dist/{tasks-F_411-nA.d.ts → tasks-D_Ah6OyC.d.ts}

@@ -234,14 +234,14 @@ interface Test<ExtraContext = object> extends TaskPopulated {
      */
     context: TaskContext<Test> & ExtraContext & TestContext;
 }
-interface Custom<ExtraContext = object> extends TaskPopulated {
-    type: 'custom';
-    /**
-     * Task context that will be passed to the test function.
-     */
-    context: TaskContext<Custom> & ExtraContext & TestContext;
-}
-type Task = Test | Suite | Custom | File;
+/**
+ * @deprecated Use `Test` instead. `type: 'custom'` is not used since 2.2
+ */
+type Custom<ExtraContext = object> = Test<ExtraContext>;
+type Task = Test | Suite | File;
+/**
+ * @deprecated Vitest doesn't provide `done()` anymore
+ */
 type DoneCallback = (error?: any) => void;
 type TestFunction<ExtraContext = object> = (context: ExtendedContext<Test> & ExtraContext) => Awaitable<any> | void;
 type ExtractEachCallbackArgs<T extends ReadonlyArray<any>> = {
@@ -261,9 +261,9 @@ interface EachFunctionReturn<T extends any[]> {
     /**
      * @deprecated Use options as the second argument instead
      */
-    (name: string | Function, fn: (...args: T) => Awaitable<void>, options: TestOptions): void;
-    (name: string | Function, fn: (...args: T) => Awaitable<void>, options?: number | TestOptions): void;
-    (name: string | Function, options: TestOptions, fn: (...args: T) => Awaitable<void>): void;
+    (name: string | Function, fn: (...args: T) => Awaitable<void>, options: TestCollectorOptions): void;
+    (name: string | Function, fn: (...args: T) => Awaitable<void>, options?: number | TestCollectorOptions): void;
+    (name: string | Function, options: TestCollectorOptions, fn: (...args: T) => Awaitable<void>): void;
 }
 interface TestEachFunction {
     <T extends any[] | [any]>(cases: ReadonlyArray<T>): EachFunctionReturn<T>;
@@ -273,7 +273,7 @@ interface TestEachFunction {
 }
 interface TestForFunctionReturn<Arg, Context> {
     (name: string | Function, fn: (arg: Arg, context: Context) => Awaitable<void>): void;
-    (name: string | Function, options: TestOptions, fn: (args: Arg, context: Context) => Awaitable<void>): void;
+    (name: string | Function, options: TestCollectorOptions, fn: (args: Arg, context: Context) => Awaitable<void>): void;
 }
 interface TestForFunction<ExtraContext> {
     <T>(cases: ReadonlyArray<T>): TestForFunctionReturn<T, ExtendedContext<Test> & ExtraContext>;
@@ -283,14 +283,15 @@ interface TestCollectorCallable<C = object> {
     /**
      * @deprecated Use options as the second argument instead
      */
-    <ExtraContext extends C>(name: string | Function, fn: TestFunction<ExtraContext>, options: TestOptions): void;
-    <ExtraContext extends C>(name: string | Function, fn?: TestFunction<ExtraContext>, options?: number | TestOptions): void;
-    <ExtraContext extends C>(name: string | Function, options?: TestOptions, fn?: TestFunction<ExtraContext>): void;
+    <ExtraContext extends C>(name: string | Function, fn: TestFunction<ExtraContext>, options: TestCollectorOptions): void;
+    <ExtraContext extends C>(name: string | Function, fn?: TestFunction<ExtraContext>, options?: number | TestCollectorOptions): void;
+    <ExtraContext extends C>(name: string | Function, options?: TestCollectorOptions, fn?: TestFunction<ExtraContext>): void;
 }
 type ChainableTestAPI<ExtraContext = object> = ChainableFunction<'concurrent' | 'sequential' | 'only' | 'skip' | 'todo' | 'fails', TestCollectorCallable<ExtraContext>, {
     each: TestEachFunction;
     for: TestForFunction<ExtraContext>;
 }>;
+type TestCollectorOptions = Omit<TestOptions, 'shuffle'>;
 interface TestOptions {
     /**
      * Test timeout.
@@ -320,6 +321,10 @@ interface TestOptions {
      * Tests inherit `sequential` from `describe()` and nested `describe()` will inherit from parent's `sequential`.
      */
     sequential?: boolean;
+    /**
+     * Whether the tasks of the suite run in a random order.
+     */
+    shuffle?: boolean;
     /**
      * Whether the test should be skipped.
      */
@@ -390,10 +395,10 @@ interface AfterAllListener {
     (suite: Readonly<Suite | File>): Awaitable<unknown>;
 }
 interface BeforeEachListener<ExtraContext = object> {
-    (context: ExtendedContext<Test | Custom> & ExtraContext, suite: Readonly<Suite>): Awaitable<unknown>;
+    (context: ExtendedContext<Test> & ExtraContext, suite: Readonly<Suite>): Awaitable<unknown>;
 }
 interface AfterEachListener<ExtraContext = object> {
-    (context: ExtendedContext<Test | Custom> & ExtraContext, suite: Readonly<Suite>): Awaitable<unknown>;
+    (context: ExtendedContext<Test> & ExtraContext, suite: Readonly<Suite>): Awaitable<unknown>;
 }
 interface SuiteHooks<ExtraContext = object> {
     beforeAll: BeforeAllListener[];
@@ -419,7 +424,7 @@ interface TaskCustomOptions extends TestOptions {
      * If nothing is provided, the runner will try to get the function using `getFn(task)`.
      * If the runner cannot find the function, the task will be marked as failed.
      */
-    handler?: (context: TaskContext<Custom>) => Awaitable<void>;
+    handler?: (context: TaskContext<Test>) => Awaitable<void>;
 }
 interface SuiteCollector<ExtraContext = object> {
     readonly name: string;
@@ -427,8 +432,8 @@ interface SuiteCollector<ExtraContext = object> {
     options?: TestOptions;
     type: 'collector';
     test: TestAPI<ExtraContext>;
-    tasks: (Suite | Custom<ExtraContext> | Test<ExtraContext> | SuiteCollector<ExtraContext>)[];
-    task: (name: string, options?: TaskCustomOptions) => Custom<ExtraContext>;
+    tasks: (Suite | Test<ExtraContext> | SuiteCollector<ExtraContext>)[];
+    task: (name: string, options?: TaskCustomOptions) => Test<ExtraContext>;
     collect: (file: File) => Promise<Suite>;
     clear: () => void;
     on: <T extends keyof SuiteHooks<ExtraContext>>(name: T, ...fn: SuiteHooks<ExtraContext>[T]) => void;
@@ -446,7 +451,7 @@ interface TestContext {
 /**
  * Context that's always available in the test function.
  */
-interface TaskContext<Task extends Custom | Test = Custom | Test> {
+interface TaskContext<Task extends Test = Test> {
     /**
      * Metadata of the current test
      */
@@ -454,24 +459,24 @@ interface TaskContext<Task extends Custom | Test = Custom | Test> {
     /**
      * Extract hooks on test failed
      */
-    onTestFailed: (fn: OnTestFailedHandler) => void;
+    onTestFailed: (fn: OnTestFailedHandler, timeout?: number) => void;
     /**
      * Extract hooks on test failed
      */
-    onTestFinished: (fn: OnTestFinishedHandler) => void;
+    onTestFinished: (fn: OnTestFinishedHandler, timeout?: number) => void;
     /**
      * Mark tests as skipped. All execution after this call will be skipped.
      * This function throws an error, so make sure you are not catching it accidentally.
      */
     skip: (note?: string) => void;
 }
-type ExtendedContext<T extends Custom | Test> = TaskContext<T> & TestContext;
-type OnTestFailedHandler = (result: TaskResult) => Awaitable<void>;
-type OnTestFinishedHandler = (result: TaskResult) => Awaitable<void>;
+type ExtendedContext<T extends Test> = TaskContext<T> & TestContext;
+type OnTestFailedHandler = (context: ExtendedContext<Test>) => Awaitable<void>;
+type OnTestFinishedHandler = (context: ExtendedContext<Test>) => Awaitable<void>;
 interface TaskHook<HookListener> {
     (fn: HookListener, timeout?: number): void;
 }
 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 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 };
+export { type AfterAllListener as A, type BeforeAllListener as B, type ChainableFunction 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 BeforeEachListener as b, createChainable as c, type AfterEachListener as d, type TaskHook as e, type OnTestFinishedHandler as f, type Custom 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 { 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-F_411-nA.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-F_411-nA.js';
+import { r as SequenceHooks, s as SequenceSetupFiles, F as File, T as Task, a as Test, S as Suite, G as TaskResultPack, v as TaskContext, E as ExtendedContext } from './tasks-D_Ah6OyC.js';
+export { A as AfterAllListener, d as AfterEachListener, B as BeforeAllListener, b as BeforeEachListener, g as Custom, 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, f 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, e 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-D_Ah6OyC.js';
 import '@vitest/utils';
 
 /**
@@ -30,6 +30,10 @@ interface VitestRunnerConfig {
     includeTaskLocation?: boolean;
     diffOptions?: DiffOptions;
 }
+interface FileSpec {
+    filepath: string;
+    testLocations: number[] | undefined;
+}
 type VitestRunnerImportSource = 'collect' | 'setup';
 interface VitestRunnerConstructor {
     new (config: VitestRunnerConfig): VitestRunner;
@@ -68,7 +72,7 @@ interface VitestRunner {
     /**
      * When the task has finished running, but before cleanup hooks are called
      */
-    onTaskFinished?: (test: Test | Custom) => unknown;
+    onTaskFinished?: (test: Test) => unknown;
     /**
      * Called after result and state are set.
      */
@@ -118,7 +122,7 @@ interface VitestRunner {
      *
      * @see https://vitest.dev/advanced/runner.html#your-task-function
      */
-    extendTaskContext?: <T extends Test | Custom>(context: TaskContext<T>) => ExtendedContext<T>;
+    extendTaskContext?: <T extends Test>(context: TaskContext<T>) => ExtendedContext<T>;
     /**
      * Called when test and setup files are imported. Can be called in two situations: when collecting tests and when importing setup files.
      */
@@ -137,4 +141,4 @@ interface VitestRunner {
     pool?: string;
 }
 
-export { type CancelReason, Custom, ExtendedContext, File, SequenceHooks, SequenceSetupFiles, Suite, Task, TaskContext, TaskResultPack, Test, type VitestRunner, type VitestRunnerConfig, type VitestRunnerConstructor, type VitestRunnerImportSource };
+export { type CancelReason, ExtendedContext, File, type FileSpec, SequenceHooks, SequenceSetupFiles, Suite, Task, TaskContext, TaskResultPack, Test, type VitestRunner, type VitestRunnerConfig, type VitestRunnerConstructor, type VitestRunnerImportSource };

package/dist/utils.d.ts

@@ -1,11 +1,11 @@
-import { S as Suite, F as File, T as Task, a as Test, C as Custom } from './tasks-F_411-nA.js';
-export { b as ChainableFunction, c as createChainable } from './tasks-F_411-nA.js';
+import { S as Suite, F as File, T as Task, a as Test } from './tasks-D_Ah6OyC.js';
+export { C as ChainableFunction, c as createChainable } from './tasks-D_Ah6OyC.js';
 import { Arrayable } from '@vitest/utils';
 
 /**
  * If any tasks been marked as `only`, mark all other tasks as `skip`.
  */
-declare function interpretTaskModes(suite: Suite, namePattern?: string | RegExp, onlyMode?: boolean, parentIsOnly?: boolean, allowOnly?: boolean): void;
+declare function interpretTaskModes(file: Suite, namePattern?: string | RegExp, testLocations?: number[] | undefined, onlyMode?: boolean, parentIsOnly?: boolean, allowOnly?: boolean): void;
 declare function someTasksAreOnly(suite: Suite): boolean;
 declare function generateHash(str: string): string;
 declare function calculateSuiteHash(parent: Suite): void;
@@ -21,8 +21,12 @@ declare function limitConcurrency(concurrency?: number): <Args extends unknown[]
  */
 declare function partitionSuiteChildren(suite: Suite): Task[][];
 
-declare function isAtomTest(s: Task): s is Test | Custom;
-declare function getTests(suite: Arrayable<Task>): (Test | Custom)[];
+/**
+ * @deprecated use `isTestCase` instead
+ */
+declare function isAtomTest(s: Task): s is Test;
+declare function isTestCase(s: Task): s is Test;
+declare function getTests(suite: Arrayable<Task>): Test[];
 declare function getTasks(tasks?: Arrayable<Task>): Task[];
 declare function getSuites(suite: Arrayable<Task>): Suite[];
 declare function hasTests(suite: Arrayable<Suite>): boolean;
@@ -31,4 +35,4 @@ declare function getNames(task: Task): string[];
 declare function getFullName(task: Task, separator?: string): string;
 declare function getTestName(task: Task, separator?: string): string;
 
-export { calculateSuiteHash, createFileTask, generateHash, getFullName, getNames, getSuites, getTasks, getTestName, getTests, hasFailed, hasTests, interpretTaskModes, isAtomTest, limitConcurrency, partitionSuiteChildren, someTasksAreOnly };
+export { calculateSuiteHash, createFileTask, generateHash, getFullName, getNames, getSuites, getTasks, getTestName, getTests, hasFailed, hasTests, interpretTaskModes, isAtomTest, isTestCase, limitConcurrency, partitionSuiteChildren, someTasksAreOnly };

package/dist/utils.js

@@ -1,4 +1,4 @@
-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';
+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, q as isTestCase, 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.2.0-beta.1",
+  "version": "3.0.0-beta.1",
   "description": "Vitest test runner",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -39,7 +39,7 @@
   ],
   "dependencies": {
     "pathe": "^1.1.2",
-    "@vitest/utils": "2.2.0-beta.1"
+    "@vitest/utils": "3.0.0-beta.1"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",