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

package/dist/chunk-tasks.js

@@ -29,39 +29,71 @@ 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, parentMatchedWithLocation) => {
+    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";
+      let hasLocationMatch = parentMatchedWithLocation;
+      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);
+          hasLocationMatch = true;
+        } else if (parentMatchedWithLocation) {
+          t.mode = "run";
+        } else if (t.type === "test") {
+          t.mode = "skip";
+        }
       }
-    } else if (t.type === "suite") {
-      if (t.mode === "skip") {
-        skipAllTasks(t);
-      } else {
-        interpretTaskModes(t, namePattern, onlyMode, includeTask, allowOnly);
+      if (t.type === "test") {
+        if (namePattern && !getTaskFullName(t).match(namePattern)) {
+          t.mode = "skip";
+        }
+      } else if (t.type === "suite") {
+        if (t.mode === "skip") {
+          skipAllTasks(t);
+        } else {
+          traverseSuite(t, includeTask, hasLocationMatch);
+        }
+      }
+    });
+    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, false);
+  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) {
@@ -119,7 +151,7 @@ function calculateSuiteHash(parent) {
 function createFileTask(filepath, root, projectName, pool) {
   const path = relative(root, filepath);
   const file = {
-    id: generateHash(`${path}${projectName || ""}`),
+    id: generateFileHash(path, projectName),
     name: path,
     type: "suite",
     mode: "run",
@@ -133,6 +165,9 @@ function createFileTask(filepath, root, projectName, pool) {
   file.file = file;
   return file;
 }
+function generateFileHash(file, projectName) {
+  return generateHash(`${file}${projectName || ""}`);
+}
 
 function limitConcurrency(concurrency = Infinity) {
   let count = 0;
@@ -182,7 +217,7 @@ function isAtomTest(s) {
   return isTestCase(s);
 }
 function isTestCase(s) {
-  return s.type === "test" || s.type === "custom";
+  return s.type === "test";
 }
 function getTests(suite) {
   const tests = [];
@@ -249,4 +284,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, generateHash as d, getFullName as e, getNames as f, generateFileHash as g, getSuites as h, interpretTaskModes as i, getTasks as j, getTestName as k, limitConcurrency as l, getTests as m, hasFailed as n, hasTests as o, partitionSuiteChildren as p, isAtomTest as q, isTestCase as r, 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-CgWT5bp6.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-CgWT5bp6.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-DaEhEbK_.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-DaEhEbK_.js';
 import { Awaitable } from '@vitest/utils';
-import { VitestRunner } from './types.js';
+import { VitestRunner, FileSpecification } 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[] | FileSpecification[], runner: VitestRunner): Promise<File[]>;
+declare function publicCollect(specs: string[] | FileSpecification[], 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, FileSpecification, 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,6 +1,6 @@
 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 { c as createChainable, b as createFileTask, a as calculateSuiteHash, s as someTasksAreOnly, i as interpretTaskModes, l as limitConcurrency, p as partitionSuiteChildren, o as hasTests, n as hasFailed } from './chunk-tasks.js';
 import { processError } from '@vitest/utils/error';
 export { processError } from '@vitest/utils/error';
 import 'pathe';
@@ -37,7 +37,6 @@ function withTimeout(fn, timeout, isHook = false) {
   const { setTimeout, clearTimeout } = getSafeTimers();
   return function runWithTimeout(...args) {
     return Promise.race([
-      fn(...args),
       new Promise((resolve, reject) => {
         var _a;
         const timer = setTimeout(() => {
@@ -45,6 +44,9 @@ function withTimeout(fn, timeout, isHook = false) {
           reject(new Error(makeTimeoutMsg(isHook, timeout)));
         }, timeout);
         (_a = timer.unref) == null ? void 0 : _a.call(timer);
+      }),
+      Promise.resolve(fn(...args)).then((result) => {
+        return new Promise((resolve) => setTimeout(resolve, 0, result));
       })
     ]);
   };
@@ -59,13 +61,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 +337,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 +373,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 +398,7 @@ function parseArguments(optionsOrFn, optionsOrTest) {
   };
 }
 function createSuiteCollector(name, factory = () => {
-}, mode, shuffle, each, suiteOptions) {
+}, mode, each, suiteOptions) {
   const tasks = [];
   const factoryQueue = [];
   let suite2;
@@ -414,9 +422,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 +491,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 +549,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 +559,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 +572,6 @@ function createSuite() {
       formatName(name),
       factory,
       mode,
-      this.shuffle,
       this.each,
       options
     );
@@ -578,7 +586,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 +629,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 +846,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 +873,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 +905,7 @@ async function collectTests(paths, runner) {
     interpretTaskModes(
       file,
       config.testNamePattern,
+      testLocations,
       hasOnlyTasks,
       false,
       config.allowOnly
@@ -933,25 +945,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 +1226,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 +1273,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 +1297,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 +1309,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-CgWT5bp6.d.ts → tasks-DaEhEbK_.d.ts}

@@ -105,14 +105,6 @@ interface TaskPopulated extends TaskBase {
      * Whether the task should succeed if it fails. If the task fails, it will be marked as passed.
      */
     fails?: boolean;
-    /**
-     * Hooks that will run if the task fails. The order depends on the `sequence.hooks` option.
-     */
-    onFailed?: OnTestFailedHandler[];
-    /**
-     * Hooks that will run after the task finishes. The order depends on the `sequence.hooks` option.
-     */
-    onFinished?: OnTestFinishedHandler[];
     /**
      * Store promises (from async expects) to wait for them before finishing the test
      */
@@ -136,7 +128,7 @@ interface TaskResult {
     state: TaskState;
     /**
      * Errors that occurred during the task execution. It is possible to have several errors
-     * if `expect.soft()` failed multiple times.
+     * if `expect.soft()` failed multiple times or `retry` was triggered.
      */
     errors?: ErrorWithDiff[];
     /**
@@ -221,38 +213,24 @@ interface File extends Suite {
      * The time it took to import the setup file.
      */
     setupDuration?: number;
-    /**
-     * Whether the file is initiated without running any tests.
-     * This is done to populate state on the server side by Vitest.
-     */
-    local?: boolean;
 }
 interface Test<ExtraContext = object> extends TaskPopulated {
     type: 'test';
     /**
      * Test context that will be passed to the test function.
      */
-    context: TaskContext<Test> & ExtraContext & TestContext;
+    context: TestContext & ExtraContext;
 }
 /**
  * @deprecated Use `Test` instead. `type: 'custom'` is not used since 2.2
  */
-interface Custom<ExtraContext = object> extends TaskPopulated {
-    /**
-     * @deprecated use `test` instead. `custom` is not used since 2.2
-     */
-    type: 'custom';
-    /**
-     * Task context that will be passed to the test function.
-     */
-    context: TaskContext<Test> & ExtraContext & TestContext;
-}
-type Task = Test | Suite | Custom | File;
+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 TestFunction<ExtraContext = object> = (context: TestContext & ExtraContext) => Awaitable<any> | void;
 type ExtractEachCallbackArgs<T extends ReadonlyArray<any>> = {
     1: [T[0]];
     2: [T[0], T[1]];
@@ -270,9 +248,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>;
@@ -282,24 +260,25 @@ 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>;
-    (strings: TemplateStringsArray, ...values: any[]): TestForFunctionReturn<any, ExtendedContext<Test> & ExtraContext>;
+    <T>(cases: ReadonlyArray<T>): TestForFunctionReturn<T, TestContext & ExtraContext>;
+    (strings: TemplateStringsArray, ...values: any[]): TestForFunctionReturn<any, TestContext & ExtraContext>;
 }
 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.
@@ -329,6 +308,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.
      */
@@ -366,7 +349,7 @@ type Use<T> = (value: T) => Promise<void>;
 type FixtureFn<T, K extends keyof T, ExtraContext> = (context: Omit<T, K> & ExtraContext, use: Use<T[K]>) => Promise<void>;
 type Fixture<T, K extends keyof T, ExtraContext = object> = ((...args: any) => any) extends T[K] ? T[K] extends any ? FixtureFn<T, K, Omit<ExtraContext, Exclude<keyof T, K>>> : never : T[K] | (T[K] extends any ? FixtureFn<T, K, Omit<ExtraContext, Exclude<keyof T, K>>> : never);
 type Fixtures<T extends Record<string, any>, ExtraContext = object> = {
-    [K in keyof T]: Fixture<T, K, ExtraContext & ExtendedContext<Test>> | [Fixture<T, K, ExtraContext & ExtendedContext<Test>>, FixtureOptions?];
+    [K in keyof T]: Fixture<T, K, ExtraContext & TestContext> | [Fixture<T, K, ExtraContext & TestContext>, FixtureOptions?];
 };
 type InferFixturesTypes<T> = T extends TestAPI<infer C> ? C : T;
 interface SuiteCollectorCallable<ExtraContext = object> {
@@ -399,10 +382,10 @@ interface AfterAllListener {
     (suite: Readonly<Suite | File>): Awaitable<unknown>;
 }
 interface BeforeEachListener<ExtraContext = object> {
-    (context: ExtendedContext<Test> & ExtraContext, suite: Readonly<Suite>): Awaitable<unknown>;
+    (context: TestContext & ExtraContext, suite: Readonly<Suite>): Awaitable<unknown>;
 }
 interface AfterEachListener<ExtraContext = object> {
-    (context: ExtendedContext<Test> & ExtraContext, suite: Readonly<Suite>): Awaitable<unknown>;
+    (context: TestContext & ExtraContext, suite: Readonly<Suite>): Awaitable<unknown>;
 }
 interface SuiteHooks<ExtraContext = object> {
     beforeAll: BeforeAllListener[];
@@ -428,7 +411,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<Test>) => Awaitable<void>;
+    handler?: (context: TestContext) => Awaitable<void>;
 }
 interface SuiteCollector<ExtraContext = object> {
     readonly name: string;
@@ -436,7 +419,7 @@ interface SuiteCollector<ExtraContext = object> {
     options?: TestOptions;
     type: 'collector';
     test: TestAPI<ExtraContext>;
-    tasks: (Suite | Custom<ExtraContext> | Test<ExtraContext> | SuiteCollector<ExtraContext>)[];
+    tasks: (Suite | Test<ExtraContext> | SuiteCollector<ExtraContext>)[];
     task: (name: string, options?: TaskCustomOptions) => Test<ExtraContext>;
     collect: (file: File) => Promise<Suite>;
     clear: () => void;
@@ -451,11 +434,6 @@ interface RuntimeContext {
  * User's custom test context.
  */
 interface TestContext {
-}
-/**
- * Context that's always available in the test function.
- */
-interface TaskContext<Task extends Test = Test> {
     /**
      * Metadata of the current test
      */
@@ -463,24 +441,31 @@ interface TaskContext<Task extends Test = 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 Test> = TaskContext<T> & TestContext;
-type OnTestFailedHandler = (result: TaskResult) => Awaitable<void>;
-type OnTestFinishedHandler = (result: TaskResult) => Awaitable<void>;
+/**
+ * Context that's always available in the test function.
+ * @deprecated use `TestContext` instead
+ */
+interface TaskContext extends TestContext {
+}
+/** @deprecated use `TestContext` instead */
+type ExtendedContext = TaskContext & TestContext;
+type OnTestFailedHandler = (context: TestContext) => Awaitable<void>;
+type OnTestFinishedHandler = (context: TestContext) => 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-CgWT5bp6.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-CgWT5bp6.js';
+import { r as SequenceHooks, s as SequenceSetupFiles, F as File, T as Task, a as Test, S as Suite, G as TaskResultPack, K as TestContext } from './tasks-DaEhEbK_.js';
+export { A as AfterAllListener, d as AfterEachListener, B as BeforeAllListener, b as BeforeEachListener, g as Custom, j as CustomAPI, 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, 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, v as TaskContext, w as TaskCustomOptions, e as TaskHook, x as TaskMeta, y as TaskPopulated, z as TaskResult, J as TaskState, j as TestAPI, L as TestFunction, M as TestOptions, U as Use } from './tasks-DaEhEbK_.js';
 import '@vitest/utils';
 
 /**
@@ -30,6 +30,13 @@ interface VitestRunnerConfig {
     includeTaskLocation?: boolean;
     diffOptions?: DiffOptions;
 }
+/**
+ * Possible options to run a single file in a test.
+ */
+interface FileSpecification {
+    filepath: string;
+    testLocations: number[] | undefined;
+}
 type VitestRunnerImportSource = 'collect' | 'setup';
 interface VitestRunnerConstructor {
     new (config: VitestRunnerConfig): VitestRunner;
@@ -68,7 +75,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.
      */
@@ -114,11 +121,9 @@ interface VitestRunner {
      * Called when new context for a test is defined. Useful if you want to add custom properties to the context.
      * If you only want to define custom context, consider using "beforeAll" in "setupFiles" instead.
      *
-     * This method is called for both "test" and "custom" handlers.
-     *
-     * @see https://vitest.dev/advanced/runner.html#your-task-function
+     * @see https://vitest.dev/advanced/runner#your-task-function
      */
-    extendTaskContext?: <T extends Test>(context: TaskContext<T>) => ExtendedContext<T>;
+    extendTaskContext?: (context: TestContext) => TestContext;
     /**
      * Called when test and setup files are imported. Can be called in two situations: when collecting tests and when importing setup files.
      */
@@ -137,4 +142,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, File, type FileSpecification, SequenceHooks, SequenceSetupFiles, Suite, Task, TaskResultPack, Test, TestContext, type VitestRunner, type VitestRunnerConfig, type VitestRunnerConstructor, type VitestRunnerImportSource };

package/dist/utils.d.ts

@@ -1,15 +1,21 @@
-import { S as Suite, F as File, T as Task, a as Test, C as Custom } from './tasks-CgWT5bp6.js';
-export { b as ChainableFunction, c as createChainable } from './tasks-CgWT5bp6.js';
+import { S as Suite, F as File, T as Task, a as Test } from './tasks-DaEhEbK_.js';
+export { C as ChainableFunction, c as createChainable } from './tasks-DaEhEbK_.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;
 declare function createFileTask(filepath: string, root: string, projectName: string | undefined, pool?: string): File;
+/**
+ * Generate a unique ID for a file based on its path and project name
+ * @param file File relative to the root of the project to keep ID the same between different machines
+ * @param projectName The name of the test project
+ */
+declare function generateFileHash(file: string, projectName: string | undefined): string;
 
 /**
  * Return a function for running multiple async operations with limited concurrency.
@@ -24,8 +30,9 @@ declare function partitionSuiteChildren(suite: Suite): Task[][];
 /**
  * @deprecated use `isTestCase` instead
  */
-declare function isAtomTest(s: Task): s is Test | Custom;
-declare function getTests(suite: Arrayable<Task>): (Test | Custom)[];
+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;
@@ -34,4 +41,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, generateFileHash, 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 generateFileHash, d as generateHash, e as getFullName, f as getNames, h as getSuites, j as getTasks, k as getTestName, m as getTests, n as hasFailed, o as hasTests, i as interpretTaskModes, q as isAtomTest, r 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.2",
+  "version": "3.0.0-beta.2",
   "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.2"
+    "@vitest/utils": "3.0.0-beta.2"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",