vitest 0.0.109 → 0.0.110

package/dist/worker.js

@@ -1,11 +1,11 @@
-import { s as slash, h as resolve, d as dirname$2, m as mergeSlashes, b as basename$2 } from './utils-d97bd6d9.js';
-import { a as spyOn, s as spies, n as nanoid } from './jest-mock-8498c46d.js';
+import { h as resolve, d as dirname$2, b as basename$2, m as mergeSlashes, s as slash } from './utils-d97bd6d9.js';
+import { a as spyOn, s as spies, n as nanoid } from './jest-mock-a57b745c.js';
 import { c as distDir } from './constants-e762cbc5.js';
 import { builtinModules, createRequire } from 'module';
 import { pathToFileURL, fileURLToPath as fileURLToPath$2, URL as URL$1 } from 'url';
-import fs, { promises, realpathSync, statSync, Stats, readdirSync, existsSync } from 'fs';
 import vm from 'vm';
 import path from 'path';
+import fs, { promises, realpathSync, statSync, Stats, readdirSync, existsSync } from 'fs';
 import assert from 'assert';
 import { format as format$2, inspect } from 'util';
 import { s as send } from './rpc-7de86f29.js';
@@ -9215,6 +9215,105 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+function resolveMockPath(mockPath, root, nmName) {
+  if (nmName) {
+    const mockFolder = resolve(root, "__mocks__");
+    const files = readdirSync(mockFolder);
+    for (const file of files) {
+      const [basename2] = file.split(".");
+      if (basename2 === nmName)
+        return resolve(mockFolder, file).replace(root, "");
+    }
+    return null;
+  }
+  const dir = dirname$2(mockPath);
+  const baseId = basename$2(mockPath);
+  const fullPath = resolve(dir, "__mocks__", baseId);
+  return existsSync(fullPath) ? fullPath.replace(root, "") : null;
+}
+function getObjectType(value) {
+  return Object.prototype.toString.apply(value).slice(8, -1);
+}
+function mockPrototype(proto) {
+  if (!proto)
+    return null;
+  const newProto = {};
+  const protoDescr = Object.getOwnPropertyDescriptors(proto);
+  for (const d in protoDescr) {
+    Object.defineProperty(newProto, d, protoDescr[d]);
+    if (typeof protoDescr[d].value === "function")
+      spyOn(newProto, d).mockImplementation(() => {
+      });
+  }
+  return newProto;
+}
+function mockObject(obj) {
+  const type = getObjectType(obj);
+  if (Array.isArray(obj))
+    return [];
+  else if (type !== "Object" && type !== "Module")
+    return obj;
+  const newObj = __spreadValues({}, obj);
+  const proto = mockPrototype(Object.getPrototypeOf(obj));
+  Object.setPrototypeOf(newObj, proto);
+  for (const k in obj) {
+    newObj[k] = mockObject(obj[k]);
+    const type2 = getObjectType(obj[k]);
+    if (type2.includes("Function") && !obj[k].__isSpy) {
+      spyOn(newObj, k).mockImplementation(() => {
+      });
+      Object.defineProperty(newObj[k], "length", { value: 0 });
+    }
+  }
+  return newObj;
+}
+function createMocker(root, mockMap) {
+  function getSuiteFilepath() {
+    var _a;
+    return (_a = process.__vitest_worker__) == null ? void 0 : _a.filepath;
+  }
+  function getActualPath(path, nmName) {
+    return nmName ? mergeSlashes(`/@fs/${path}`) : path.replace(root, "");
+  }
+  function unmockPath(path, nmName) {
+    const suitefile = getSuiteFilepath();
+    if (suitefile) {
+      const fsPath = getActualPath(path, nmName);
+      mockMap[suitefile] ?? (mockMap[suitefile] = {});
+      delete mockMap[suitefile][fsPath];
+    }
+  }
+  function mockPath(path, nmName, factory) {
+    const suitefile = getSuiteFilepath();
+    if (suitefile) {
+      const fsPath = getActualPath(path, nmName);
+      mockMap[suitefile] ?? (mockMap[suitefile] = {});
+      mockMap[suitefile][fsPath] = factory || resolveMockPath(path, root, nmName);
+    }
+  }
+  function clearMocks({ clearMocks: clearMocks2, mockReset, restoreMocks }) {
+    if (!clearMocks2 && !mockReset && !restoreMocks)
+      return;
+    spies.forEach((s) => {
+      if (restoreMocks)
+        s.mockRestore();
+      else if (mockReset)
+        s.mockReset();
+      else if (clearMocks2)
+        s.mockClear();
+    });
+  }
+  return {
+    mockPath,
+    unmockPath,
+    clearMocks,
+    getActualPath,
+    mockObject,
+    getSuiteFilepath,
+    resolveMockPath
+  };
+}
+
 const defaultInline = [
   "vitest/dist",
   /virtual:/,
@@ -9262,84 +9361,46 @@ async function interpretedImport(path, interpretDefault) {
   }
   return mod;
 }
-function resolveMockPath(mockPath, root, nmName) {
-  if (nmName) {
-    const mockFolder = resolve(root, "__mocks__");
-    const files = readdirSync(mockFolder);
-    for (const file of files) {
-      const [basename2] = file.split(".");
-      if (basename2 === nmName)
-        return resolve(mockFolder, file).replace(root, "");
-    }
-    return null;
-  }
-  const dir = dirname$2(mockPath);
-  const baseId = basename$2(mockPath);
-  const fullPath = resolve(dir, "__mocks__", baseId);
-  return existsSync(fullPath) ? fullPath.replace(root, "") : null;
-}
-function mockObject(obj) {
-  const newObj = __spreadValues({}, obj);
-  for (const k in obj) {
-    newObj[k] = obj[k];
-    if (typeof obj[k] === "function" && !obj[k].__isSpy)
-      spyOn(newObj, k);
-  }
-  return newObj;
-}
 async function executeInViteNode(options) {
   const { moduleCache, root, files, fetch, mockMap } = options;
   const externalCache = /* @__PURE__ */ new Map();
   builtinModules.forEach((m) => externalCache.set(m, true));
+  const {
+    getActualPath,
+    getSuiteFilepath,
+    mockObject,
+    mockPath,
+    clearMocks,
+    unmockPath,
+    resolveMockPath
+  } = createMocker(root, mockMap);
   const result = [];
   for (const file of files)
     result.push(await cachedRequest(`/@fs/${slash(resolve(file))}`, []));
   return result;
-  function getSuiteFilepath() {
+  async function callFunctionMock(dep, mock) {
     var _a;
-    return (_a = process.__vitest_worker__) == null ? void 0 : _a.filepath;
-  }
-  function getActualPath(path, nmName) {
-    return nmName ? mergeSlashes(`/@fs/${path}`) : path.replace(root, "");
-  }
-  function unmockPath(path, nmName) {
-    const suitefile = getSuiteFilepath();
-    if (suitefile) {
-      const fsPath = getActualPath(path, nmName);
-      mockMap[suitefile] ?? (mockMap[suitefile] = {});
-      delete mockMap[suitefile][fsPath];
-    }
-  }
-  function mockPath(path, nmName) {
-    const suitefile = getSuiteFilepath();
-    if (suitefile) {
-      const mockPath2 = resolveMockPath(path, root, nmName);
-      const fsPath = getActualPath(path, nmName);
-      mockMap[suitefile] ?? (mockMap[suitefile] = {});
-      mockMap[suitefile][fsPath] = mockPath2;
-    }
-  }
-  function clearMocks({ clearMocks: clearMocks2, mockReset, restoreMocks }) {
-    if (!clearMocks2 && !mockReset && !restoreMocks)
-      return;
-    spies.forEach((s) => {
-      if (restoreMocks)
-        s.mockRestore();
-      else if (mockReset)
-        s.mockReset();
-      else if (clearMocks2)
-        s.mockClear();
-    });
+    const name = `${dep}__mock`;
+    const cached = (_a = moduleCache.get(name)) == null ? void 0 : _a.exports;
+    if (cached)
+      return cached;
+    const exports = await mock();
+    setCache(name, { exports });
+    return exports;
   }
   async function directRequest(id, fsPath, callstack) {
     callstack = [...callstack, id];
     const suite = getSuiteFilepath();
     const request = async (dep, canMock = true) => {
       var _a;
-      const mocks2 = mockMap[suite || ""] || {};
-      const mock = mocks2[dep];
-      if (mock && canMock)
-        dep = mock;
+      if (canMock) {
+        const mocks2 = mockMap[suite || ""] || {};
+        const mock = mocks2[dep];
+        if (typeof mock === "function")
+          return callFunctionMock(dep, mock);
+        if (typeof mock === "string")
+          dep = mock;
+      }
       if (callstack.includes(dep)) {
         const cacheKey = toFilePath(dep, root);
         if (!((_a = moduleCache.get(cacheKey)) == null ? void 0 : _a.exports))
@@ -9372,12 +9433,18 @@ ${[...callstack, dep].reverse().map((p) => `- ${p}`).join("\n")}`);
       return request(getActualPath(path, nmName), false);
     };
     const importMock = async (path, nmName) => {
-      const mockPath2 = resolveMockPath(path, root, nmName);
-      if (mockPath2 === null) {
-        const exports2 = await request(getActualPath(path, nmName), false);
-        return mockObject(exports2);
+      if (!suite)
+        throw new Error("You can import mock only inside of a running test");
+      const mock = (mockMap[suite] || {})[path] || resolveMockPath(path, root, nmName);
+      if (mock === null) {
+        const fsPath2 = getActualPath(path, nmName);
+        const exports2 = mockObject(await request(fsPath2, false));
+        setCache(fsPath2, { exports: exports2 });
+        return exports2;
       }
-      return request(mockPath2, true);
+      if (typeof mock === "function")
+        return callFunctionMock(path, mock);
+      return request(mock, true);
     };
     const context = {
       __vite_ssr_import__: request,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest",
-  "version": "0.0.109",
+  "version": "0.0.110",
   "description": "A blazing fast unit test framework powered by Vite",
   "keywords": [
     "vite",