vitest 0.26.3 → 0.27.0

package/dist/{chunk-runtime-error.f5c8aaf2.js → chunk-runtime-error.fad2c32b.js}

@@ -1,7 +1,7 @@
 import util$1 from 'util';
 import { util } from 'chai';
-import { a as stringify } from './chunk-utils-timers.715da787.js';
-import { x as deepClone, g as getWorkerState, y as getType } from './chunk-typecheck-constants.06e1fe5b.js';
+import { a as stringify } from './chunk-utils-timers.52534f96.js';
+import { w as deepClone, g as getWorkerState, x as getType } from './chunk-mock-date.a1c85759.js';
 
 const IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
 const IS_COLLECTION_SYMBOL = "@@__IMMUTABLE_ITERABLE__@@";

package/dist/{chunk-runtime-mocker.887bf8c8.js → chunk-runtime-mocker.a677dd28.js}

@@ -2,9 +2,10 @@ import { ViteNodeRunner } from 'vite-node/client';
 import { isInternalRequest } from 'vite-node/utils';
 import { normalizePath } from 'vite';
 import { i as isNodeBuiltin } from './vendor-index.2e96c50b.js';
-import { g as getWorkerState, y as getType, K as getAllMockableProperties, e as getCurrentEnvironment } from './chunk-typecheck-constants.06e1fe5b.js';
+import { g as getWorkerState, x as getType, H as getAllMockableProperties, d as getCurrentEnvironment } from './chunk-mock-date.a1c85759.js';
 import { existsSync, readdirSync } from 'node:fs';
-import { b as resolve, e as distDir, g as isAbsolute, p as picocolors, d as dirname, j as join, c as basename, l as extname } from './chunk-utils-env.3fdc1793.js';
+import { b as resolve, f as distDir, h as isAbsolute, d as dirname, j as join, c as basename, e as extname } from './chunk-utils-env.b861e3a0.js';
+import c from 'picocolors';
 
 class RefTracker {
   constructor() {
@@ -105,7 +106,7 @@ const _VitestMocker = class {
             `[vitest] No "${String(prop)}" export is defined on the "${mockpath}" mock. Did you forget to return it from "vi.mock"?
 If you need to partially mock a module, you can use "vi.importActual" inside:
 
-${picocolors.exports.green(`vi.mock("${mockpath}", async () => {
+${c.green(`vi.mock("${mockpath}", async () => {
   const actual = await vi.importActual("${mockpath}")
   return {
     ...actual,
@@ -281,8 +282,7 @@ ${picocolors.exports.green(`vi.mock("${mockpath}", async () => {
       return result;
     }
     if (typeof mock === "string" && !callstack.includes(mock))
-      url = mock;
-    return url;
+      return mock;
   }
   queueMock(id, importer, factory) {
     _VitestMocker.pendingIds.push({ type: "mock", id, importer, factory });
@@ -339,7 +339,9 @@ class VitestRunner extends ViteNodeRunner {
     });
   }
   shouldInterop(path, mod) {
-    return this.options.interopDefault ?? (getCurrentEnvironment() !== "node" && super.shouldInterop(path, mod));
+    if (this.options.interopDefault === false)
+      return false;
+    return (this.options.interopDefault || getCurrentEnvironment() !== "node") && super.shouldInterop(path, mod);
   }
 }
 

package/dist/{chunk-runtime-rpc.54d72169.js → chunk-runtime-rpc.7f83c8a9.js}

@@ -1,5 +1,5 @@
-import { g as getWorkerState } from './chunk-typecheck-constants.06e1fe5b.js';
-import { s as safeSetTimeout } from './chunk-utils-timers.715da787.js';
+import { g as getWorkerState } from './chunk-mock-date.a1c85759.js';
+import { s as safeSetTimeout } from './chunk-utils-timers.52534f96.js';
 
 const safeRandom = Math.random;
 function withSafeTimers(fn) {

package/dist/{chunk-runtime-setup.a06d5c72.js → chunk-runtime-setup.731b2b04.js}

@@ -1,14 +1,14 @@
 import { performance } from 'perf_hooks';
-import { s as someTasksAreOnly, i as interpretTaskModes, t as takeCoverageInsideWorker, p as pLimit } from './chunk-integrations-coverage.befed097.js';
-import { r as resetRunOnceCounter, i as index, v as vi, s as setCurrentTest } from './chunk-utils-import.e7f64637.js';
-import { g as getWorkerState, R as RealDate, t as toArray, l as relativePath, j as isRunningInBenchmark, p as partitionSuiteChildren, q as shuffle, u as hasTests, v as hasFailed, w as createDefer, f as getFullName } from './chunk-typecheck-constants.06e1fe5b.js';
-import { f as clearCollectorContext, h as defaultSuite, j as setHooks, k as getHooks, l as collectorContext, m as getBenchOptions, n as getFn, o as setState, G as GLOBAL_EXPECT, p as getState } from './chunk-runtime-chain.f51aa930.js';
-import { r as rpc } from './chunk-runtime-rpc.54d72169.js';
-import { p as processError } from './chunk-runtime-error.f5c8aaf2.js';
+import { g as generateHash, c as calculateSuiteHash, s as someTasksAreOnly, i as interpretTaskModes, t as takeCoverageInsideWorker, p as pLimit } from './chunk-integrations-coverage.44413252.js';
+import { f as clearCollectorContext, h as defaultSuite, j as setHooks, k as getHooks, l as collectorContext, m as getBenchOptions, n as getFn, o as setState, p as getSnapshotClient, G as GLOBAL_EXPECT, q as getState } from './chunk-runtime-chain.6df5a66b.js';
+import { r as resetRunOnceCounter, i as index, v as vi, s as setCurrentTest } from './chunk-utils-import.2baa69a9.js';
+import { g as getWorkerState, R as RealDate, t as toArray, k as relativePath, h as isRunningInBenchmark, p as partitionSuiteChildren, l as shuffle, q as hasTests, u as hasFailed, v as createDefer, e as getFullName } from './chunk-mock-date.a1c85759.js';
+import { r as rpc } from './chunk-runtime-rpc.7f83c8a9.js';
+import { p as processError } from './chunk-runtime-error.fad2c32b.js';
 import { installSourcemapsSupport } from 'vite-node/source-map';
 import { e as environments } from './chunk-env-node.b3664da2.js';
-import { i as isNode, a as isBrowser } from './chunk-utils-env.3fdc1793.js';
-import { b as safeClearTimeout, s as safeSetTimeout } from './chunk-utils-timers.715da787.js';
+import { i as isNode, a as isBrowser } from './chunk-utils-env.b861e3a0.js';
+import { b as safeClearTimeout, s as safeSetTimeout } from './chunk-utils-timers.52534f96.js';
 
 let globalSetup = false;
 async function setupGlobalEnv(config) {
@@ -29,7 +29,7 @@ async function setupGlobalEnv(config) {
     await setupConsoleLogSpy();
   }
   if (config.globals)
-    (await import('./chunk-integrations-globals.ee28730b.js')).registerApiGlobally();
+    (await import('./chunk-integrations-globals.3dfaeb99.js')).registerApiGlobally();
 }
 function setupDefines(defines) {
   for (const key in defines)
@@ -170,32 +170,21 @@ async function runSetupFiles(config) {
 }
 
 const now$1 = Date.now;
-function hash(str) {
-  let hash2 = 0;
-  if (str.length === 0)
-    return `${hash2}`;
-  for (let i = 0; i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    hash2 = (hash2 << 5) - hash2 + char;
-    hash2 = hash2 & hash2;
-  }
-  return `${hash2}`;
-}
 async function collectTests(paths, config) {
   const files = [];
   const browserHashMap = getWorkerState().browserHashMap;
   async function importFromBrowser(filepath) {
     const match = filepath.match(/^(\w:\/)/);
-    const hash2 = browserHashMap.get(filepath);
+    const hash = browserHashMap.get(filepath);
     if (match)
-      return await import(`/@fs/${filepath.slice(match[1].length)}?v=${hash2}`);
+      return await import(`/@fs/${filepath.slice(match[1].length)}?v=${hash}`);
     else
-      return await import(`${filepath}?v=${hash2}`);
+      return await import(`${filepath}?v=${hash}`);
   }
   for (const filepath of paths) {
     const path = relativePath(config.root, filepath);
     const file = {
-      id: hash(path),
+      id: generateHash(path),
       name: path,
       type: "suite",
       mode: "run",
@@ -230,27 +219,22 @@ async function collectTests(paths, config) {
       }
       file.collectDuration = now$1() - collectStart;
     } catch (e) {
+      const error = processError(e);
       file.result = {
         state: "fail",
-        error: processError(e)
+        error,
+        errors: [error]
       };
       if (config.browser)
         console.error(e);
     }
-    calculateHash(file);
+    calculateSuiteHash(file);
     const hasOnlyTasks = someTasksAreOnly(file);
     interpretTaskModes(file, config.testNamePattern, hasOnlyTasks, false, config.allowOnly);
     files.push(file);
   }
   return files;
 }
-function calculateHash(parent) {
-  parent.tasks.forEach((t, idx) => {
-    t.id = `${parent.id}_${idx}`;
-    if (t.type === "suite")
-      calculateHash(t);
-  });
-}
 
 async function importTinybench() {
   if (!globalThis.EventTarget)
@@ -330,8 +314,8 @@ const callCleanupHooks = async (cleanups) => {
 async function runTest(test) {
   var _a, _b, _c;
   if (test.mode !== "run") {
-    const { getSnapshotClient } = await import('./chunk-runtime-chain.f51aa930.js').then(function (n) { return n.r; });
-    getSnapshotClient().skipTestSnapshots(test);
+    const { getSnapshotClient: getSnapshotClient2 } = await import('./chunk-runtime-chain.6df5a66b.js').then(function (n) { return n.u; });
+    getSnapshotClient2().skipTestSnapshots(test);
     return;
   }
   if (((_a = test.result) == null ? void 0 : _a.state) === "fail") {
@@ -347,8 +331,8 @@ async function runTest(test) {
   clearModuleMocks();
   setCurrentTest(test);
   if (isNode) {
-    const { getSnapshotClient } = await import('./chunk-runtime-chain.f51aa930.js').then(function (n) { return n.r; });
-    await getSnapshotClient().setTest(test);
+    const { getSnapshotClient: getSnapshotClient2 } = await import('./chunk-runtime-chain.6df5a66b.js').then(function (n) { return n.u; });
+    await getSnapshotClient2().setTest(test);
   }
   const workerState = getWorkerState();
   workerState.current = test;
@@ -363,7 +347,8 @@ async function runTest(test) {
         expectedAssertionsNumber: null,
         expectedAssertionsNumberErrorGen: null,
         testPath: (_b = test.suite.file) == null ? void 0 : _b.filepath,
-        currentTestName: getFullName(test)
+        currentTestName: getFullName(test),
+        snapshotState: getSnapshotClient().snapshotState
       }, globalThis[GLOBAL_EXPECT]);
       beforeEachCleanups = await callSuiteHook(test.suite, test, "beforeEach", [test.context, test.suite]);
       test.result.retryCount = retryCount;
@@ -381,15 +366,19 @@ async function runTest(test) {
         throw isExpectingAssertionsError;
       test.result.state = "pass";
     } catch (e) {
+      const error = processError(e);
       test.result.state = "fail";
-      test.result.error = processError(e);
+      test.result.error = error;
+      test.result.errors = [error];
     }
     try {
       await callSuiteHook(test.suite, test, "afterEach", [test.context, test.suite]);
       await callCleanupHooks(beforeEachCleanups);
     } catch (e) {
+      const error = processError(e);
       test.result.state = "fail";
-      test.result.error = processError(e);
+      test.result.error = error;
+      test.result.errors = [error];
     }
     if (test.result.state === "pass")
       break;
@@ -399,19 +388,22 @@ async function runTest(test) {
     await Promise.all(((_c = test.onFailed) == null ? void 0 : _c.map((fn) => fn(test.result))) || []);
   if (test.fails) {
     if (test.result.state === "pass") {
+      const error = processError(new Error("Expect test to fail"));
       test.result.state = "fail";
-      test.result.error = processError(new Error("Expect test to fail"));
+      test.result.error = error;
+      test.result.errors = [error];
     } else {
       test.result.state = "pass";
       test.result.error = void 0;
+      test.result.errors = void 0;
     }
   }
   if (isBrowser && test.result.error)
     console.error(test.result.error.message, test.result.error.stackStr);
   setCurrentTest(void 0);
   if (isNode) {
-    const { getSnapshotClient } = await import('./chunk-runtime-chain.f51aa930.js').then(function (n) { return n.r; });
-    getSnapshotClient().clearTest();
+    const { getSnapshotClient: getSnapshotClient2 } = await import('./chunk-runtime-chain.6df5a66b.js').then(function (n) { return n.u; });
+    getSnapshotClient2().clearTest();
   }
   test.result.duration = now() - start;
   if (workerState.config.logHeapUsage && isNode)
@@ -472,8 +464,10 @@ async function runSuite(suite) {
       await callSuiteHook(suite, suite, "afterAll", [suite]);
       await callCleanupHooks(beforeAllCleanups);
     } catch (e) {
+      const error = processError(e);
       suite.result.state = "fail";
-      suite.result.error = processError(e);
+      suite.result.error = error;
+      suite.result.errors = [error];
     }
   }
   suite.result.duration = now() - start;
@@ -482,8 +476,11 @@ async function runSuite(suite) {
   if (suite.mode === "run") {
     if (!hasTests(suite)) {
       suite.result.state = "fail";
-      if (!suite.result.error)
-        suite.result.error = new Error(`No test found in suite ${suite.name}`);
+      if (!suite.result.error) {
+        const error = processError(new Error(`No test found in suite ${suite.name}`));
+        suite.result.error = error;
+        suite.result.errors = [error];
+      }
     } else if (hasFailed(suite)) {
       suite.result.state = "fail";
     } else {
@@ -590,13 +587,15 @@ async function runSuites(suites) {
     await runSuite(suite);
 }
 async function runFiles(files, config) {
-  var _a;
+  var _a, _b;
   for (const file of files) {
     if (!file.tasks.length && !config.passWithNoTests) {
-      if (!((_a = file.result) == null ? void 0 : _a.error)) {
+      if (!((_b = (_a = file.result) == null ? void 0 : _a.errors) == null ? void 0 : _b.length)) {
+        const error = processError(new Error(`No test suite found in file ${file.filepath}`));
         file.result = {
           state: "fail",
-          error: new Error(`No test suite found in file ${file.filepath}`)
+          error,
+          errors: [error]
         };
       }
     }
@@ -616,12 +615,12 @@ async function startTestsBrowser(paths, config) {
 async function startTestsNode(paths, config) {
   const files = await collectTests(paths, config);
   rpc().onCollected(files);
-  const { getSnapshotClient } = await import('./chunk-runtime-chain.f51aa930.js').then(function (n) { return n.r; });
-  getSnapshotClient().clear();
+  const { getSnapshotClient: getSnapshotClient2 } = await import('./chunk-runtime-chain.6df5a66b.js').then(function (n) { return n.u; });
+  getSnapshotClient2().clear();
   await runFiles(files, config);
   const coverage = await takeCoverageInsideWorker(config.coverage);
   rpc().onAfterSuiteRun({ coverage });
-  await getSnapshotClient().saveCurrent();
+  await getSnapshotClient2().saveCurrent();
   await sendTasksUpdate();
 }
 async function startTests(paths, config) {