@vitest/runner 0.29.8 → 0.30.1

package/dist/chunk-tasks.js

@@ -1,4 +1,5 @@
 import { format, deepClone, stringify, getOwnProperties, getType, toArray } from '@vitest/utils';
+import { unifiedDiff } from '@vitest/utils/diff';
 
 function partitionSuiteChildren(suite) {
   let tasksGroup = [];
@@ -18,7 +19,9 @@ function partitionSuiteChildren(suite) {
 
 const IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
 const IS_COLLECTION_SYMBOL = "@@__IMMUTABLE_ITERABLE__@@";
-const isImmutable = (v) => v && (v[IS_COLLECTION_SYMBOL] || v[IS_RECORD_SYMBOL]);
+function isImmutable(v) {
+  return v && (v[IS_COLLECTION_SYMBOL] || v[IS_RECORD_SYMBOL]);
+}
 const OBJECT_PROTO = Object.getPrototypeOf({});
 function getUnserializableMessage(err) {
   if (err instanceof Error)
@@ -90,13 +93,12 @@ function processError(err, options = {}) {
   const clonedActual = deepClone(err.actual);
   const clonedExpected = deepClone(err.expected);
   const { replacedActual, replacedExpected } = replaceAsymmetricMatcher(clonedActual, clonedExpected);
-  err.actual = replacedActual;
-  err.expected = replacedExpected;
-  const maxDiffSize = options.outputDiffMaxSize ?? 1e4;
+  if (err.showDiff || err.showDiff === void 0 && err.expected !== void 0 && err.actual !== void 0)
+    err.diff = unifiedDiff(replacedActual, replacedExpected, options);
   if (typeof err.expected !== "string")
-    err.expected = stringify(err.expected, 10, { maxLength: maxDiffSize });
+    err.expected = stringify(err.expected, 10);
   if (typeof err.actual !== "string")
-    err.actual = stringify(err.actual, 10, { maxLength: maxDiffSize });
+    err.actual = stringify(err.actual, 10);
   try {
     if (typeof err.message === "string")
       err.message = normalizeErrorMessage(err.message);

package/dist/index.d.ts

@@ -1,25 +1,27 @@
-import { V as VitestRunner } from './runner-b9659804.js';
-export { V as VitestRunner, a as VitestRunnerConfig, c as VitestRunnerConstructor, b as VitestRunnerImportSource } from './runner-b9659804.js';
-import { T as Task, F as File, S as SuiteAPI, a as TestAPI, b as SuiteCollector, c as SuiteHooks, H as HookListener, d as TestContext, e as Suite, f as HookCleanupCallback, O as OnTestFailedHandler, g as Test } from './tasks-3fbb29e4.js';
-export { D as DoneCallback, F as File, f as HookCleanupCallback, H as HookListener, O as OnTestFailedHandler, R as RunMode, p as RuntimeContext, q as SequenceHooks, r as SequenceSetupFiles, e as Suite, S as SuiteAPI, b as SuiteCollector, o as SuiteFactory, c as SuiteHooks, T as Task, i as TaskBase, j as TaskCustom, k as TaskResult, l as TaskResultPack, h as TaskState, g as Test, a as TestAPI, d as TestContext, m as TestFunction, n as TestOptions } from './tasks-3fbb29e4.js';
+import { V as VitestRunner } from './runner-3b8473ea.js';
+export { a as VitestRunnerConfig, c as VitestRunnerConstructor, b as VitestRunnerImportSource } from './runner-3b8473ea.js';
+import { T as Task, F as File, S as SuiteAPI, a as TestAPI, b as SuiteCollector, c as SuiteHooks, O as OnTestFailedHandler, d as Test } from './tasks-c965d7f6.js';
+export { D as DoneCallback, m as HookCleanupCallback, H as HookListener, R as RunMode, o as RuntimeContext, q as SequenceHooks, r as SequenceSetupFiles, j as Suite, n as SuiteFactory, f as TaskBase, g as TaskCustom, h as TaskResult, i as TaskResultPack, e as TaskState, p as TestContext, k as TestFunction, l as TestOptions } from './tasks-c965d7f6.js';
 import { Awaitable } from '@vitest/utils';
 
 declare function updateTask(task: Task, runner: VitestRunner): void;
 declare function startTests(paths: string[], runner: VitestRunner): Promise<File[]>;
 
-declare const suite: SuiteAPI<{}>;
-declare const test: TestAPI<{}>;
-declare const describe: SuiteAPI<{}>;
-declare const it: TestAPI<{}>;
+declare const suite: SuiteAPI;
+declare const test: TestAPI;
+declare const describe: SuiteAPI;
+declare const it: TestAPI;
 declare function getCurrentSuite<ExtraContext = {}>(): SuiteCollector<ExtraContext>;
 
-declare const beforeAll: (fn: SuiteHooks['beforeAll'][0], timeout?: number) => void;
-declare const afterAll: (fn: SuiteHooks['afterAll'][0], timeout?: number) => void;
-declare const beforeEach: <ExtraContext = {}>(fn: HookListener<[TestContext & ExtraContext, Suite], HookCleanupCallback>, timeout?: number) => void;
-declare const afterEach: <ExtraContext = {}>(fn: HookListener<[TestContext & ExtraContext, Suite], void>, timeout?: number) => void;
+declare function beforeAll(fn: SuiteHooks['beforeAll'][0], timeout?: number): void;
+declare function afterAll(fn: SuiteHooks['afterAll'][0], timeout?: number): void;
+declare function beforeEach<ExtraContext = {}>(fn: SuiteHooks<ExtraContext>['beforeEach'][0], timeout?: number): void;
+declare function afterEach<ExtraContext = {}>(fn: SuiteHooks<ExtraContext>['afterEach'][0], timeout?: number): void;
 declare const onTestFailed: (fn: OnTestFailedHandler) => void;
 
 declare function setFn(key: Test, fn: (() => Awaitable<void>)): void;
 declare function getFn<Task = Test>(key: Task): (() => Awaitable<void>);
 
-export { afterAll, afterEach, beforeAll, beforeEach, describe, getCurrentSuite, getFn, it, onTestFailed, setFn, startTests, suite, test, updateTask };
+declare function getCurrentTest(): Test<{}> | undefined;
+
+export { File, OnTestFailedHandler, SuiteAPI, SuiteCollector, SuiteHooks, Task, Test, TestAPI, VitestRunner, afterAll, afterEach, beforeAll, beforeEach, describe, getCurrentSuite, getCurrentTest, getFn, it, onTestFailed, setFn, startTests, suite, test, updateTask };

package/dist/index.js

@@ -2,6 +2,7 @@ import limit from 'p-limit';
 import { getSafeTimers, format, isObject, objDisplay, objectAttr, noop, toArray, shuffle } from '@vitest/utils';
 import { c as createChainable, g as generateHash, p as processError, a as calculateSuiteHash, s as someTasksAreOnly, i as interpretTaskModes, b as partitionSuiteChildren, h as hasTests, d as hasFailed } from './chunk-tasks.js';
 import { relative } from 'pathe';
+import '@vitest/utils/diff';
 
 const fnMap = /* @__PURE__ */ new WeakMap();
 const hooksMap = /* @__PURE__ */ new WeakMap();
@@ -247,7 +248,11 @@ function formatTitle(template, items, idx) {
   if (isObject(items[0])) {
     formatted = formatted.replace(
       /\$([$\w_.]+)/g,
-      (_, key) => objDisplay(objectAttr(items[0], key))
+      (_, key) => {
+        var _a;
+        return objDisplay(objectAttr(items[0], key), (_a = runner == null ? void 0 : runner.config) == null ? void 0 : _a.chaiConfig);
+      }
+      // https://github.com/chaijs/chai/pull/1490
     );
   }
   return formatted;
@@ -285,7 +290,7 @@ async function collectTests(paths, runner) {
   for (const filepath of paths) {
     const path = relative(config.root, filepath);
     const file = {
-      id: generateHash(path),
+      id: generateHash(`${path}${config.name || ""}`),
       name: path,
       type: "suite",
       mode: "run",
@@ -405,13 +410,13 @@ async function sendTasksUpdate(runner) {
     return p;
   }
 }
-const callCleanupHooks = async (cleanups) => {
+async function callCleanupHooks(cleanups) {
   await Promise.all(cleanups.map(async (fn) => {
     if (typeof fn !== "function")
       return;
     await fn();
   }));
-};
+}
 async function runTest(test, runner) {
   var _a, _b, _c, _d, _e, _f;
   await ((_a = runner.onBeforeRunTest) == null ? void 0 : _a.call(runner, test));
@@ -443,6 +448,12 @@ async function runTest(test, runner) {
           throw new Error("Test function is not found. Did you add it using `setFn`?");
         await fn();
       }
+      if (test.promises) {
+        const result = await Promise.allSettled(test.promises);
+        const errors = result.map((r) => r.status === "rejected" ? r.reason : void 0).filter(Boolean);
+        if (errors.length)
+          throw errors;
+      }
       await ((_d = runner.onAfterTryTest) == null ? void 0 : _d.call(runner, test, retryCount));
       test.result.state = "pass";
     } catch (e) {
@@ -479,10 +490,13 @@ async function runTest(test, runner) {
 }
 function failTask(result, err) {
   result.state = "fail";
-  const error = processError(err);
-  result.error = error;
-  result.errors ?? (result.errors = []);
-  result.errors.push(error);
+  const errors = Array.isArray(err) ? err : [err];
+  for (const e of errors) {
+    const error = processError(e);
+    result.error ?? (result.error = error);
+    result.errors ?? (result.errors = []);
+    result.errors.push(error);
+  }
 }
 function markTasksAsSkipped(suite, runner) {
   suite.tasks.forEach((t) => {
@@ -597,11 +611,21 @@ async function startTests(paths, runner) {
   return files;
 }
 
-const getDefaultHookTimeout = () => getRunner().config.hookTimeout;
-const beforeAll = (fn, timeout) => getCurrentSuite().on("beforeAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
-const afterAll = (fn, timeout) => getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
-const beforeEach = (fn, timeout) => getCurrentSuite().on("beforeEach", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
-const afterEach = (fn, timeout) => getCurrentSuite().on("afterEach", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
+function getDefaultHookTimeout() {
+  return getRunner().config.hookTimeout;
+}
+function beforeAll(fn, timeout) {
+  return getCurrentSuite().on("beforeAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
+}
+function afterAll(fn, timeout) {
+  return getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
+}
+function beforeEach(fn, timeout) {
+  return getCurrentSuite().on("beforeEach", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
+}
+function afterEach(fn, timeout) {
+  return getCurrentSuite().on("afterEach", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
+}
 const onTestFailed = createTestHook("onTestFailed", (test, handler) => {
   test.onFailed || (test.onFailed = []);
   test.onFailed.push(handler);
@@ -615,4 +639,4 @@ function createTestHook(name, handler) {
   };
 }
 
-export { afterAll, afterEach, beforeAll, beforeEach, describe, getCurrentSuite, getFn, it, onTestFailed, setFn, startTests, suite, test, updateTask };
+export { afterAll, afterEach, beforeAll, beforeEach, describe, getCurrentSuite, getCurrentTest, getFn, it, onTestFailed, setFn, startTests, suite, test, updateTask };

package/dist/{runner-b9659804.d.ts → runner-3b8473ea.d.ts}

@@ -1,4 +1,4 @@
-import { q as SequenceHooks, r as SequenceSetupFiles, F as File, g as Test, e as Suite, k as TaskResult, d as TestContext } from './tasks-3fbb29e4.js';
+import { q as SequenceHooks, r as SequenceSetupFiles, F as File, d as Test, j as Suite, h as TaskResult, p as TestContext } from './tasks-c965d7f6.js';
 
 interface VitestRunnerConfig {
     root: string;
@@ -13,6 +13,9 @@ interface VitestRunnerConfig {
         hooks: SequenceHooks;
         setupFiles: SequenceSetupFiles;
     };
+    chaiConfig?: {
+        truncateThreshold?: number;
+    };
     maxConcurrency: number;
     testTimeout: number;
     hookTimeout: number;

package/dist/{tasks-3fbb29e4.d.ts → tasks-c965d7f6.d.ts}

@@ -1,4 +1,4 @@
-import { Awaitable } from '@vitest/utils';
+import { ErrorWithDiff, Awaitable } from '@vitest/utils';
 
 type ChainableFunction<T extends string, Args extends any[], R = any, E = {}> = {
     (...args: Args): R;
@@ -9,35 +9,6 @@ type ChainableFunction<T extends string, Args extends any[], R = any, E = {}> =
 } & E;
 declare function createChainable<T extends string, Args extends any[], R = any, E = {}>(keys: T[], fn: (this: Record<T, boolean | undefined>, ...args: Args) => R): ChainableFunction<T, Args, R, E>;
 
-interface ParsedStack {
-    method: string;
-    file: string;
-    line: number;
-    column: number;
-}
-interface ErrorWithDiff extends Error {
-    name: string;
-    nameStr?: string;
-    stack?: string;
-    stackStr?: string;
-    stacks?: ParsedStack[];
-    showDiff?: boolean;
-    actual?: any;
-    expected?: any;
-    operator?: string;
-    type?: string;
-    frame?: string;
-}
-declare function serializeError(val: any, seen?: WeakMap<object, any>): any;
-interface ProcessErrorOptions {
-    outputDiffMaxSize?: number;
-}
-declare function processError(err: any, options?: ProcessErrorOptions): any;
-declare function replaceAsymmetricMatcher(actual: any, expected: any, actualReplaced?: WeakSet<object>, expectedReplaced?: WeakSet<object>): {
-    replacedActual: any;
-    replacedExpected: any;
-};
-
 type RunMode = 'run' | 'skip' | 'only' | 'todo';
 type TaskState = RunMode | 'pass' | 'fail';
 interface TaskBase {
@@ -88,6 +59,10 @@ interface Test<ExtraContext = {}> extends TaskBase {
     fails?: boolean;
     context: TestContext & ExtraContext;
     onFailed?: OnTestFailedHandler[];
+    /**
+     * Store promises (from async expects) to wait for them before finishing the test
+     */
+    promises?: Promise<any>[];
 }
 type Task = Test | Suite | TaskCustom | File;
 type DoneCallback = (error?: any) => void;
@@ -193,4 +168,4 @@ type OnTestFailedHandler = (result: TaskResult) => Awaitable<void>;
 type SequenceHooks = 'stack' | 'list' | 'parallel';
 type SequenceSetupFiles = 'list' | 'parallel';
 
-export { ChainableFunction as C, DoneCallback as D, ErrorWithDiff as E, File as F, HookListener as H, OnTestFailedHandler as O, ParsedStack as P, RunMode as R, SuiteAPI as S, Task as T, TestAPI as a, SuiteCollector as b, SuiteHooks as c, TestContext as d, Suite as e, HookCleanupCallback as f, Test as g, TaskState as h, TaskBase as i, TaskCustom as j, TaskResult as k, TaskResultPack as l, TestFunction as m, TestOptions as n, SuiteFactory as o, RuntimeContext as p, SequenceHooks as q, SequenceSetupFiles as r, createChainable as s, serializeError as t, processError as u, replaceAsymmetricMatcher as v };
+export { ChainableFunction as C, DoneCallback as D, File as F, HookListener as H, OnTestFailedHandler as O, RunMode as R, SuiteAPI as S, Task as T, TestAPI as a, SuiteCollector as b, SuiteHooks as c, Test as d, TaskState as e, TaskBase as f, TaskCustom as g, TaskResult as h, TaskResultPack as i, Suite as j, TestFunction as k, TestOptions as l, HookCleanupCallback as m, SuiteFactory as n, RuntimeContext as o, TestContext as p, SequenceHooks as q, SequenceSetupFiles as r, createChainable as s };

package/dist/types.d.ts

@@ -1,3 +1,3 @@
-export { D as DoneCallback, F as File, f as HookCleanupCallback, H as HookListener, O as OnTestFailedHandler, R as RunMode, p as RuntimeContext, q as SequenceHooks, r as SequenceSetupFiles, e as Suite, S as SuiteAPI, b as SuiteCollector, o as SuiteFactory, c as SuiteHooks, T as Task, i as TaskBase, j as TaskCustom, k as TaskResult, l as TaskResultPack, h as TaskState, g as Test, a as TestAPI, d as TestContext, m as TestFunction, n as TestOptions } from './tasks-3fbb29e4.js';
-export { V as VitestRunner, a as VitestRunnerConfig, c as VitestRunnerConstructor, b as VitestRunnerImportSource } from './runner-b9659804.js';
+export { D as DoneCallback, F as File, m as HookCleanupCallback, H as HookListener, O as OnTestFailedHandler, R as RunMode, o as RuntimeContext, q as SequenceHooks, r as SequenceSetupFiles, j as Suite, S as SuiteAPI, b as SuiteCollector, n as SuiteFactory, c as SuiteHooks, T as Task, f as TaskBase, g as TaskCustom, h as TaskResult, i as TaskResultPack, e as TaskState, d as Test, a as TestAPI, p as TestContext, k as TestFunction, l as TestOptions } from './tasks-c965d7f6.js';
+export { V as VitestRunner, a as VitestRunnerConfig, c as VitestRunnerConstructor, b as VitestRunnerImportSource } from './runner-3b8473ea.js';
 import '@vitest/utils';

package/dist/utils.d.ts

@@ -1,6 +1,15 @@
-import { e as Suite, T as Task, g as Test, j as TaskCustom } from './tasks-3fbb29e4.js';
-export { C as ChainableFunction, E as ErrorWithDiff, P as ParsedStack, s as createChainable, u as processError, v as replaceAsymmetricMatcher, t as serializeError } from './tasks-3fbb29e4.js';
+import { j as Suite, T as Task, d as Test, g as TaskCustom } from './tasks-c965d7f6.js';
+export { C as ChainableFunction, s as createChainable } from './tasks-c965d7f6.js';
 import { Arrayable } from '@vitest/utils';
+export { ErrorWithDiff, ParsedStack } from '@vitest/utils';
+import { DiffOptions } from '@vitest/utils/diff';
+
+declare function serializeError(val: any, seen?: WeakMap<object, any>): any;
+declare function processError(err: any, options?: DiffOptions): any;
+declare function replaceAsymmetricMatcher(actual: any, expected: any, actualReplaced?: WeakSet<object>, expectedReplaced?: WeakSet<object>): {
+    replacedActual: any;
+    replacedExpected: any;
+};
 
 /**
  * If any tasks been marked as `only`, mark all other tasks as `skip`.
@@ -22,4 +31,4 @@ declare function hasTests(suite: Arrayable<Suite>): boolean;
 declare function hasFailed(suite: Arrayable<Task>): boolean;
 declare function getNames(task: Task): string[];
 
-export { calculateSuiteHash, generateHash, getNames, getSuites, getTasks, getTests, hasFailed, hasTests, interpretTaskModes, partitionSuiteChildren, someTasksAreOnly };
+export { calculateSuiteHash, generateHash, getNames, getSuites, getTasks, getTests, hasFailed, hasTests, interpretTaskModes, partitionSuiteChildren, processError, replaceAsymmetricMatcher, serializeError, someTasksAreOnly };

package/dist/utils.js

@@ -1,2 +1,3 @@
 export { a as calculateSuiteHash, c as createChainable, g as generateHash, k as getNames, j as getSuites, f as getTasks, e as getTests, d as hasFailed, h as hasTests, i as interpretTaskModes, b as partitionSuiteChildren, p as processError, r as replaceAsymmetricMatcher, l as serializeError, s as someTasksAreOnly } from './chunk-tasks.js';
 import '@vitest/utils';
+import '@vitest/utils/diff';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/runner",
   "type": "module",
-  "version": "0.29.8",
+  "version": "0.30.1",
   "description": "Vitest test runner",
   "license": "MIT",
   "repository": {
@@ -33,9 +33,10 @@
     "*.d.ts"
   ],
   "dependencies": {
+    "concordance": "^5.0.4",
     "p-limit": "^4.0.0",
     "pathe": "^1.1.0",
-    "@vitest/utils": "0.29.8"
+    "@vitest/utils": "0.30.1"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",