vitest 0.0.107 → 0.0.111

package/dist/worker.js

@@ -1,11 +1,11 @@
-import { d as slash, m as resolve, j as dirname$2, a as spyOn, u as mergeSlashes, s as spies, k as basename$2 } from './utils-92ec89d1.js';
-import { n as nanoid } from './index-9e71c815.js';
-import { c as distDir } from './constants-82dad049.js';
+import { h as resolve, d as dirname$2, b as basename$2, m as mergeSlashes, s as slash } from './utils-cb6b1266.js';
+import { a as spyOn, s as spies, n as nanoid } from './jest-mock-a57b745c.js';
+import { c as distDir } from './constants-2b0310b7.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,
@@ -9523,10 +9590,13 @@ async function startViteNode(ctx) {
   return _viteNode;
 }
 function init(ctx) {
+  if (process.__vitest_worker__ && ctx.config.threads)
+    throw new Error(`worker for ${ctx.files.join(",")} already initialized by ${process.__vitest_worker__.ctx.files.join(",")}. This is probably an internal bug of Vitest.`);
   process.stdout.write("\0");
   const { config, port } = ctx;
   const rpcPromiseMap = /* @__PURE__ */ new Map();
   process.__vitest_worker__ = {
+    ctx,
     moduleCache,
     config,
     rpc: (method, ...args) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest",
-  "version": "0.0.107",
+  "version": "0.0.111",
   "description": "A blazing fast unit test framework powered by Vite",
   "keywords": [
     "vite",
@@ -51,16 +51,16 @@
     "@types/chai-subset": "^1.3.3",
     "chai": "^4.3.4",
     "local-pkg": "^0.4.0",
-    "tinypool": "^0.0.5",
-    "tinyspy": "^0.2.4"
+    "tinypool": "^0.0.6",
+    "tinyspy": "^0.2.6"
   },
   "devDependencies": {
     "@antfu/install-pkg": "^0.1.0",
-    "@types/diff": "^5.0.1",
+    "@types/diff": "^5.0.2",
     "@types/jsdom": "^16.2.14",
     "@types/micromatch": "^4.0.2",
     "@types/natural-compare": "^1.4.1",
-    "@types/node": "^17.0.2",
+    "@types/node": "^17.0.4",
     "@types/prompts": "^2.4.0",
     "c8": "^7.10.0",
     "cac": "^6.7.12",
@@ -84,7 +84,7 @@
     "pkg-types": "^0.3.2",
     "pretty-format": "^27.4.2",
     "prompts": "^2.4.2",
-    "rollup": "^2.61.1",
+    "rollup": "^2.62.0",
     "source-map-js": "^1.0.1",
     "strip-ansi": "^7.0.1",
     "typescript": "^4.5.4"

package/dist/global-0f4da031.js

@@ -1,19 +0,0 @@
-import { g as globalApis } from './constants-82dad049.js';
-import { i as index } from './index-77f19d39.js';
-import 'url';
-import './utils-92ec89d1.js';
-import 'tty';
-import 'local-pkg';
-import 'path';
-import 'chai';
-import 'tinyspy';
-import './suite-ff89a82e.js';
-import './index-9e71c815.js';
-
-function registerApiGlobally() {
-  globalApis.forEach((api) => {
-    globalThis[api] = index[api];
-  });
-}
-
-export { registerApiGlobally };

package/dist/index-9e71c815.js

@@ -1,12 +0,0 @@
-let urlAlphabet =
-  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
-let nanoid = (size = 21) => {
-  let id = '';
-  let i = size;
-  while (i--) {
-    id += urlAlphabet[(Math.random() * 64) | 0];
-  }
-  return id
-};
-
-export { nanoid as n };

package/dist/suite-ff89a82e.js

@@ -1,201 +0,0 @@
-import { n as nanoid } from './index-9e71c815.js';
-import { n as noop } from './utils-92ec89d1.js';
-
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-function createChainable(keys, fn) {
-  function create(obj) {
-    const chain2 = function(...args) {
-      return fn.apply(obj, args);
-    };
-    for (const key of keys) {
-      Object.defineProperty(chain2, key, {
-        get() {
-          return create(__spreadProps(__spreadValues({}, obj), { [key]: true }));
-        }
-      });
-    }
-    return chain2;
-  }
-  const chain = create({});
-  chain.fn = fn;
-  return chain;
-}
-
-const context = {
-  tasks: [],
-  currentSuite: null
-};
-function collectTask(task) {
-  var _a;
-  (_a = context.currentSuite) == null ? void 0 : _a.tasks.push(task);
-}
-async function runWithSuite(suite, fn) {
-  const prev = context.currentSuite;
-  context.currentSuite = suite;
-  await fn();
-  context.currentSuite = prev;
-}
-function getDefaultTestTimeout() {
-  return process.__vitest_worker__.config.testTimeout;
-}
-function getDefaultHookTimeout() {
-  return process.__vitest_worker__.config.hookTimeout;
-}
-function withTimeout(fn, _timeout) {
-  const timeout = _timeout ?? getDefaultTestTimeout();
-  if (timeout <= 0 || timeout === Infinity)
-    return fn;
-  return (...args) => {
-    return Promise.race([fn(...args), new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        clearTimeout(timer);
-        reject(new Error(`Test timed out in ${timeout}ms.`));
-      }, timeout);
-      timer.unref();
-    })]);
-  };
-}
-function ensureAsyncTest(fn) {
-  if (!fn.length)
-    return fn;
-  return () => new Promise((resolve, reject) => {
-    const done = (...args) => args[0] ? reject(args[0]) : resolve();
-    fn(done);
-  });
-}
-function normalizeTest(fn, timeout) {
-  return withTimeout(ensureAsyncTest(fn), timeout);
-}
-
-const fnMap = /* @__PURE__ */ new WeakMap();
-const hooksMap = /* @__PURE__ */ new WeakMap();
-function setFn(key, fn) {
-  fnMap.set(key, fn);
-}
-function getFn(key) {
-  return fnMap.get(key);
-}
-function setHooks(key, hooks) {
-  hooksMap.set(key, hooks);
-}
-function getHooks(key) {
-  return hooksMap.get(key);
-}
-
-const suite = createSuite();
-const test = createChainable(["concurrent", "skip", "only", "todo", "fails"], function(name, fn, timeout) {
-  getCurrentSuite().test.fn.call(this, name, fn, timeout);
-});
-const describe = suite;
-const it = test;
-const defaultSuite = suite("");
-function clearContext() {
-  context.tasks.length = 0;
-  defaultSuite.clear();
-  context.currentSuite = defaultSuite;
-}
-function getCurrentSuite() {
-  return context.currentSuite || defaultSuite;
-}
-function createSuiteHooks() {
-  return {
-    beforeAll: [],
-    afterAll: [],
-    beforeEach: [],
-    afterEach: []
-  };
-}
-function createSuiteCollector(name, factory = () => {
-}, mode, suiteComputeMode) {
-  const tasks = [];
-  const factoryQueue = [];
-  let suite2;
-  initSuite();
-  const test2 = createChainable(["concurrent", "skip", "only", "todo", "fails"], function(name2, fn, timeout) {
-    const mode2 = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
-    const computeMode = this.concurrent ? "concurrent" : void 0;
-    const test3 = {
-      id: nanoid(),
-      type: "test",
-      name: name2,
-      mode: mode2,
-      computeMode: computeMode ?? (suiteComputeMode ?? "serial"),
-      suite: void 0,
-      fails: this.fails
-    };
-    setFn(test3, normalizeTest(fn || noop, timeout));
-    tasks.push(test3);
-  });
-  const collector = {
-    type: "collector",
-    name,
-    mode,
-    test: test2,
-    tasks,
-    collect,
-    clear,
-    on: addHook
-  };
-  function addHook(name2, ...fn) {
-    getHooks(suite2)[name2].push(...fn);
-  }
-  function initSuite() {
-    suite2 = {
-      id: nanoid(),
-      type: "suite",
-      computeMode: "serial",
-      name,
-      mode,
-      tasks: []
-    };
-    setHooks(suite2, createSuiteHooks());
-  }
-  function clear() {
-    tasks.length = 0;
-    factoryQueue.length = 0;
-    initSuite();
-  }
-  async function collect(file) {
-    factoryQueue.length = 0;
-    if (factory)
-      await runWithSuite(collector, () => factory(test2));
-    const allChildren = await Promise.all([...factoryQueue, ...tasks].map((i) => i.type === "collector" ? i.collect(file) : i));
-    suite2.file = file;
-    suite2.tasks = allChildren;
-    allChildren.forEach((task) => {
-      task.suite = suite2;
-      if (file)
-        task.file = file;
-    });
-    return suite2;
-  }
-  collectTask(collector);
-  return collector;
-}
-function createSuite() {
-  return createChainable(["concurrent", "skip", "only", "todo"], function(name, factory) {
-    const mode = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
-    const computeMode = this.concurrent ? "concurrent" : void 0;
-    return createSuiteCollector(name, factory, mode, computeMode);
-  });
-}
-
-export { getDefaultHookTimeout as a, defaultSuite as b, clearContext as c, describe as d, setHooks as e, getHooks as f, getCurrentSuite as g, context as h, it as i, getFn as j, suite as s, test as t, withTimeout as w };