vitest 0.25.8 → 0.26.1

package/dist/{chunk-runtime-mocker.99b910d0.js → chunk-runtime-mocker.3fa602ba.js}

@@ -1,9 +1,10 @@
-import { V as ViteNodeRunner } from './chunk-vite-node-source-map.b4ea5792.js';
+import { ViteNodeRunner } from 'vite-node/client';
+import { isInternalRequest } from 'vite-node/utils';
 import { normalizePath } from 'vite';
-import { g as getWorkerState, J as mergeSlashes, s as slash, x as getType, K as getAllMockableProperties } from './chunk-typecheck-constants.ed987901.js';
-import { existsSync, readdirSync } from 'fs';
-import { c as normalizeRequestId, p as pathFromRoot, i as isNodeBuiltin } from './chunk-vite-node-utils.0e4a6a88.js';
-import { p as picocolors, d as dirname, j as join, c as basename, l as extname, b as resolve, e as distDir } from './chunk-utils-env.03f840f2.js';
+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 { 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';
 
 class RefTracker {
   constructor() {
@@ -27,20 +28,21 @@ function isSpecialProp(prop, parentType) {
   return parentType.includes("Function") && typeof prop === "string" && ["arguments", "callee", "caller", "length", "name"].includes(prop);
 }
 const _VitestMocker = class {
-  constructor(options, moduleCache, request) {
-    this.options = options;
-    this.moduleCache = moduleCache;
-    this.request = request;
+  constructor(runner) {
+    this.runner = runner;
     this.resolveCache = /* @__PURE__ */ new Map();
   }
   get root() {
-    return this.options.root;
+    return this.runner.options.root;
   }
   get base() {
-    return this.options.base;
+    return this.runner.options.base;
   }
   get mockMap() {
-    return this.options.mockMap;
+    return this.runner.options.mockMap;
+  }
+  get moduleCache() {
+    return this.runner.moduleCache;
   }
   getSuiteFilepath() {
     return getWorkerState().filepath || "global";
@@ -54,21 +56,22 @@ const _VitestMocker = class {
       ...suiteMocks
     };
   }
-  async resolvePath(id, importer) {
-    const path = await this.options.resolveId(id, importer);
-    const external = path == null || path.id.includes("/node_modules/") ? id : null;
+  async resolvePath(rawId, importer) {
+    const [id, fsPath] = await this.runner.resolveUrl(rawId, importer);
+    const external = !isAbsolute(fsPath) || fsPath.includes("/node_modules/") ? rawId : null;
     return {
-      path: normalizeRequestId((path == null ? void 0 : path.id) || id),
+      id,
+      fsPath,
       external
     };
   }
   async resolveMocks() {
     await Promise.all(_VitestMocker.pendingIds.map(async (mock) => {
-      const { path, external } = await this.resolvePath(mock.id, mock.importer);
+      const { fsPath, external } = await this.resolvePath(mock.id, mock.importer);
       if (mock.type === "unmock")
-        this.unmockPath(path);
+        this.unmockPath(fsPath);
       if (mock.type === "mock")
-        this.mockPath(mock.id, path, external, mock.factory);
+        this.mockPath(mock.id, fsPath, external, mock.factory);
     }));
     _VitestMocker.pendingIds = [];
   }
@@ -82,15 +85,15 @@ const _VitestMocker = class {
       exports = await mock();
     } catch (err) {
       const vitestError = new Error(
-        "[vitest] There was an error, when mocking a module. If you are using vi.mock, make sure you are not using top level variables inside, since this call is hoisted. Read more: https://vitest.dev/api/#vi-mock"
+        '[vitest] There was an error, when mocking a module. If you are using "vi.mock" factory, make sure there are no top level variables inside, since this call is hoisted to top of the file. Read more: https://vitest.dev/api/#vi-mock'
       );
       vitestError.cause = err;
       throw vitestError;
     }
-    if (exports === null || typeof exports !== "object")
-      throw new Error('[vitest] vi.mock(path: string, factory?: () => unknown) is not returning an object. Did you mean to return an object with a "default" key?');
-    const filepath = dep.slice("mock:".length);
+    const filepath = dep.slice(5);
     const mockpath = ((_b = this.resolveCache.get(this.getSuiteFilepath())) == null ? void 0 : _b[filepath]) || filepath;
+    if (exports === null || typeof exports !== "object")
+      throw new Error(`[vitest] vi.mock("${mockpath}", factory?: () => unknown) is not returning an object. Did you mean to return an object with a "default" key?`);
     const moduleExports = new Proxy(exports, {
       get(target, prop) {
         const val = target[prop];
@@ -106,7 +109,7 @@ ${picocolors.exports.green(`vi.mock("${mockpath}", async () => {
   const actual = await vi.importActual("${mockpath}")
   return {
     ...actual,
-    // your mock
+    // your mocked methods
   },
 })`)}
 `
@@ -125,15 +128,10 @@ ${picocolors.exports.green(`vi.mock("${mockpath}", async () => {
     return this.getMocks()[id];
   }
   normalizePath(path) {
-    return pathFromRoot(this.root, normalizeRequestId(path, this.base));
-  }
-  getFsPath(path, external) {
-    if (external)
-      return mergeSlashes(`/@fs/${path}`);
-    return normalizeRequestId(path, this.base);
+    return this.moduleCache.normalizePath(path);
   }
   resolveMockPath(mockPath, external) {
-    const path = normalizeRequestId(external || mockPath);
+    const path = external || mockPath;
     if (external || isNodeBuiltin(mockPath) || !existsSync(mockPath)) {
       const mockDirname = dirname(path);
       const mockFolder = join(this.root, "__mocks__", mockDirname);
@@ -235,41 +233,35 @@ ${picocolors.exports.green(`vi.mock("${mockpath}", async () => {
     this.mockMap.set(suitefile, mocks);
     this.resolveCache.set(suitefile, resolves);
   }
-  async importActual(id, importer) {
-    const { path, external } = await this.resolvePath(id, importer);
-    const fsPath = this.getFsPath(path, external);
-    const result = await this.request(fsPath);
+  async importActual(rawId, importee) {
+    const { id, fsPath } = await this.resolvePath(rawId, importee);
+    const result = await this.runner.cachedRequest(id, fsPath, [importee]);
     return result;
   }
-  async importMock(id, importer) {
-    const { path, external } = await this.resolvePath(id, importer);
-    const fsPath = this.getFsPath(path, external);
+  async importMock(rawId, importee) {
+    const { id, fsPath, external } = await this.resolvePath(rawId, importee);
     const normalizedId = this.normalizePath(fsPath);
     let mock = this.getDependencyMock(normalizedId);
     if (mock === void 0)
       mock = this.resolveMockPath(fsPath, external);
     if (mock === null) {
-      await this.ensureSpy();
-      const mod = await this.request(fsPath);
+      const mod = await this.runner.cachedRequest(id, fsPath, [importee]);
       return this.mockObject(mod);
     }
     if (typeof mock === "function")
       return this.callFunctionMock(fsPath, mock);
-    return this.requestWithMock(mock);
+    return this.runner.dependencyRequest(mock, mock, [importee]);
   }
-  async ensureSpy() {
+  async initializeSpyModule() {
     if (_VitestMocker.spyModule)
       return;
-    _VitestMocker.spyModule = await this.request(`/@fs/${slash(resolve(distDir, "spy.js"))}`);
-  }
-  async requestWithMock(dep) {
-    await Promise.all([
-      this.ensureSpy(),
-      this.resolveMocks()
-    ]);
-    const id = this.normalizePath(dep);
+    _VitestMocker.spyModule = await this.runner.executeId(_VitestMocker.spyModulePath);
+  }
+  async requestWithMock(url, callstack) {
+    if (_VitestMocker.pendingIds.length)
+      await this.resolveMocks();
+    const id = this.normalizePath(url);
     const mock = this.getDependencyMock(id);
-    const callstack = this.request.callstack;
     const mockPath = this.getMockPath(id);
     if (mock === null) {
       const cache = this.moduleCache.get(mockPath);
@@ -277,11 +269,11 @@ ${picocolors.exports.green(`vi.mock("${mockpath}", async () => {
         return cache.exports;
       const exports = {};
       this.moduleCache.set(mockPath, { exports });
-      const mod = await this.request(dep);
+      const mod = await this.runner.directRequest(url, url, []);
       this.mockObject(mod, exports);
       return exports;
     }
-    if (typeof mock === "function" && !callstack.includes(mockPath)) {
+    if (typeof mock === "function" && !callstack.includes(mockPath) && !callstack.includes(url)) {
       callstack.push(mockPath);
       const result = await this.callFunctionMock(mockPath, mock);
       const indexMock = callstack.indexOf(mockPath);
@@ -289,8 +281,8 @@ ${picocolors.exports.green(`vi.mock("${mockpath}", async () => {
       return result;
     }
     if (typeof mock === "string" && !callstack.includes(mock))
-      dep = mock;
-    return this.request(dep);
+      url = mock;
+    return url;
   }
   queueMock(id, importer, factory) {
     _VitestMocker.pendingIds.push({ type: "mock", id, importer, factory });
@@ -301,10 +293,12 @@ ${picocolors.exports.green(`vi.mock("${mockpath}", async () => {
 };
 let VitestMocker = _VitestMocker;
 VitestMocker.pendingIds = [];
+VitestMocker.spyModulePath = resolve(distDir, "spy.js");
 
 async function executeInViteNode(options) {
   const runner = new VitestRunner(options);
   await runner.executeId("/@vite/env");
+  await runner.mocker.initializeSpyModule();
   const result = [];
   for (const file of options.files)
     result.push(await runner.executeFile(file));
@@ -314,25 +308,39 @@ class VitestRunner extends ViteNodeRunner {
   constructor(options) {
     super(options);
     this.options = options;
+    this.mocker = new VitestMocker(this);
+  }
+  shouldResolveId(id, _importee) {
+    if (isInternalRequest(id))
+      return false;
+    const environment = getCurrentEnvironment();
+    return environment === "node" ? !isNodeBuiltin(id) : true;
+  }
+  async resolveUrl(id, importee) {
+    if (importee && importee.startsWith("mock:"))
+      importee = importee.slice(5);
+    return super.resolveUrl(id, importee);
+  }
+  async dependencyRequest(id, fsPath, callstack) {
+    const mocked = await this.mocker.requestWithMock(fsPath, callstack);
+    if (typeof mocked === "string")
+      return super.dependencyRequest(mocked, mocked, callstack);
+    if (mocked && typeof mocked === "object")
+      return mocked;
+    return super.dependencyRequest(id, fsPath, callstack);
   }
   prepareContext(context) {
-    const request = context.__vite_ssr_import__;
-    const resolveId = context.__vitest_resolve_id__;
-    const resolveUrl = async (dep) => {
-      const [id, resolvedId] = await resolveId(dep);
-      return resolvedId || id;
-    };
-    const mocker = new VitestMocker(this.options, this.moduleCache, request);
     const workerState = getWorkerState();
     if (workerState.filepath && normalizePath(workerState.filepath) === normalizePath(context.__filename)) {
       Object.defineProperty(context.__vite_ssr_import_meta__, "vitest", { get: () => globalThis.__vitest_index__ });
     }
     return Object.assign(context, {
-      __vite_ssr_import__: async (dep) => mocker.requestWithMock(await resolveUrl(dep)),
-      __vite_ssr_dynamic_import__: async (dep) => mocker.requestWithMock(await resolveUrl(dep)),
-      __vitest_mocker__: mocker
+      __vitest_mocker__: this.mocker
     });
   }
+  shouldInterop(path, mod) {
+    return this.options.interopDefault ?? (getCurrentEnvironment() !== "node" && super.shouldInterop(path, mod));
+  }
 }
 
 export { VitestRunner as V, executeInViteNode as e };

package/dist/{chunk-runtime-rpc.42aebbb9.js → chunk-runtime-rpc.54d72169.js}

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

package/dist/{chunk-runtime-setup.5398e2c4.js → chunk-runtime-setup.9cdedce6.js}

@@ -1,31 +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-runtime-test-state.3f86f48f.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-typecheck-constants.ed987901.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.f86e5250.js';
-import { r as rpc } from './chunk-runtime-rpc.42aebbb9.js';
-import { p as processError } from './chunk-runtime-error.616e92ca.js';
-import { s as sourceMapSupport } from './vendor-source-map-support.1ce17397.js';
-import { e as environments } from './chunk-env-node.67948209.js';
-import { i as isNode, a as isBrowser } from './chunk-utils-env.03f840f2.js';
-import { b as safeClearTimeout, s as safeSetTimeout } from './chunk-utils-timers.793fd179.js';
-
-function installSourcemapsSupport(options) {
-  sourceMapSupport.exports.install({
-    environment: "node",
-    handleUncaughtExceptions: false,
-    retrieveSourceMap(source) {
-      const map = options.getSourceMap(source);
-      if (map) {
-        return {
-          url: source,
-          map
-        };
-      }
-      return null;
-    }
-  });
-}
+import { r as resetRunOnceCounter, i as index, v as vi, s as setCurrentTest } from './chunk-utils-import.afe2ffde.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.4cd984be.js';
+import { r as rpc } from './chunk-runtime-rpc.54d72169.js';
+import { p as processError } from './chunk-runtime-error.f5c8aaf2.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';
 
 let globalSetup = false;
 async function setupGlobalEnv(config) {
@@ -46,7 +29,7 @@ async function setupGlobalEnv(config) {
     await setupConsoleLogSpy();
   }
   if (config.globals)
-    (await import('./chunk-integrations-globals.4d261bb8.js')).registerApiGlobally();
+    (await import('./chunk-integrations-globals.96914902.js')).registerApiGlobally();
 }
 function setupDefines(defines) {
   for (const key in defines)
@@ -57,8 +40,8 @@ async function setupConsoleLogSpy() {
   const stderrBuffer = /* @__PURE__ */ new Map();
   const timers = /* @__PURE__ */ new Map();
   const unknownTestId = "__vitest__unknown_test__";
-  const { Writable } = await import('stream');
-  const { Console } = await import('console');
+  const { Writable } = await import('node:stream');
+  const { Console } = await import('node:console');
   function schedule(taskId) {
     const timer = timers.get(taskId);
     const { stdoutTime, stderrTime } = timer;
@@ -346,7 +329,7 @@ const callCleanupHooks = async (cleanups) => {
 async function runTest(test) {
   var _a, _b, _c;
   if (test.mode !== "run") {
-    const { getSnapshotClient } = await import('./chunk-runtime-chain.f86e5250.js').then(function (n) { return n.r; });
+    const { getSnapshotClient } = await import('./chunk-runtime-chain.4cd984be.js').then(function (n) { return n.r; });
     getSnapshotClient().skipTestSnapshots(test);
     return;
   }
@@ -363,7 +346,7 @@ async function runTest(test) {
   clearModuleMocks();
   setCurrentTest(test);
   if (isNode) {
-    const { getSnapshotClient } = await import('./chunk-runtime-chain.f86e5250.js').then(function (n) { return n.r; });
+    const { getSnapshotClient } = await import('./chunk-runtime-chain.4cd984be.js').then(function (n) { return n.r; });
     await getSnapshotClient().setTest(test);
   }
   const workerState = getWorkerState();
@@ -426,7 +409,7 @@ async function runTest(test) {
     console.error(test.result.error.message, test.result.error.stackStr);
   setCurrentTest(void 0);
   if (isNode) {
-    const { getSnapshotClient } = await import('./chunk-runtime-chain.f86e5250.js').then(function (n) { return n.r; });
+    const { getSnapshotClient } = await import('./chunk-runtime-chain.4cd984be.js').then(function (n) { return n.r; });
     getSnapshotClient().clearTest();
   }
   test.result.duration = now() - start;
@@ -632,7 +615,7 @@ 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.f86e5250.js').then(function (n) { return n.r; });
+  const { getSnapshotClient } = await import('./chunk-runtime-chain.4cd984be.js').then(function (n) { return n.r; });
   getSnapshotClient().clear();
   await runFiles(files, config);
   const coverage = await takeCoverageInsideWorker(config.coverage);
@@ -647,13 +630,17 @@ async function startTests(paths, config) {
     return startTestsNode(paths, config);
 }
 function clearModuleMocks() {
-  const { clearMocks, mockReset, restoreMocks } = getWorkerState().config;
+  const { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = getWorkerState().config;
   if (restoreMocks)
     vi.restoreAllMocks();
   else if (mockReset)
     vi.resetAllMocks();
   else if (clearMocks)
     vi.clearAllMocks();
+  if (unstubEnvs)
+    vi.unstubAllEnvs();
+  if (unstubGlobals)
+    vi.unstubAllGlobals();
 }
 
 export { setupGlobalEnv as a, startTests as s, withEnv as w };