vitest 0.0.103 → 0.0.104

package/dist/worker.js

@@ -1,16 +1,18 @@
-import { s as slash, h as resolve, d as dirname$2 } from './utils-c8e62373.js';
+import { d as slash, m as resolve, j as dirname$2, a as spyOn, q as mergeSlashes, s as spies, k as basename$2 } from './utils-49e5008c.js';
 import { n as nanoid } from './index-9e71c815.js';
-import { c as distDir } from './constants-a1417084.js';
+import { c as distDir } from './constants-c4dc2ff5.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 } from 'fs';
 import assert from 'assert';
 import { format as format$2, inspect } from 'util';
 import { s as send } from './rpc-7de86f29.js';
 import 'tty';
 import 'local-pkg';
+import 'chai';
+import 'tinyspy';
 
 const BUILTIN_MODULES$1 = new Set(builtinModules);
 function normalizeSlash$1(str) {
@@ -9197,6 +9199,22 @@ async function isValidNodeImport(id, _opts = {}) {
   return hasCJSSyntax(code) || !hasESMSyntax(code);
 }
 
+var __defProp = Object.defineProperty;
+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;
+};
 const defaultInline = [
   "vitest/dist",
   /virtual:/,
@@ -9244,18 +9262,84 @@ 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 } = options;
+  const { moduleCache, root, files, fetch, mockMap } = options;
   const externalCache = /* @__PURE__ */ new Map();
   builtinModules.forEach((m) => externalCache.set(m, true));
   const result = [];
   for (const file of files)
     result.push(await cachedRequest(`/@fs/${slash(resolve(file))}`, []));
   return result;
+  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) {
+    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();
+    });
+  }
   async function directRequest(id, fsPath, callstack) {
     callstack = [...callstack, id];
-    const request = async (dep) => {
+    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 (callstack.includes(dep)) {
         const cacheKey = toFilePath(dep, root);
         if (!((_a = moduleCache.get(cacheKey)) == null ? void 0 : _a.exports))
@@ -9284,12 +9368,28 @@ ${[...callstack, dep].reverse().map((p) => `- ${p}`).join("\n")}`);
         return exports.default;
       }
     };
+    const importActual = (path, nmName) => {
+      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);
+      }
+      return request(mockPath2, true);
+    };
     const context = {
       __vite_ssr_import__: request,
       __vite_ssr_dynamic_import__: request,
       __vite_ssr_exports__: exports,
       __vite_ssr_exportAll__: (obj) => exportAll(exports, obj),
       __vite_ssr_import_meta__: { url },
+      __vitest__mock__: mockPath,
+      __vitest__unmock__: unmockPath,
+      __vitest__importActual__: importActual,
+      __vitest__importMock__: importMock,
+      __vitest__clearMocks__: clearMocks,
       require: createRequire(url),
       exports,
       module: moduleProxy,
@@ -9302,6 +9402,11 @@ ${[...callstack, dep].reverse().map((p) => `- ${p}`).join("\n")}`);
       lineOffset: 0
     });
     await fn(...Object.values(context));
+    const mocks = suite ? mockMap[suite] : null;
+    if (mocks) {
+      if (mocks[id] === null)
+        exportAll(exports, mockObject(exports));
+    }
     return exports;
   }
   function setCache(id, mod) {
@@ -9387,6 +9492,7 @@ function patchWindowsImportPath(path) {
 
 let _viteNode;
 const moduleCache = /* @__PURE__ */ new Map();
+const mockMap = {};
 async function startViteNode(ctx) {
   if (_viteNode)
     return _viteNode;
@@ -9410,7 +9516,8 @@ async function startViteNode(ctx) {
     inline: config.depsInline,
     external: config.depsExternal,
     interpretDefault: config.interpretDefault,
-    moduleCache
+    moduleCache,
+    mockMap
   }))[0];
   _viteNode = { run: run2, collect: collect2 };
   return _viteNode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest",
-  "version": "0.0.103",
+  "version": "0.0.104",
   "description": "A blazing fast unit test framework powered by Vite",
   "keywords": [
     "vite",
@@ -73,6 +73,7 @@
     "happy-dom": "^2.25.0",
     "jsdom": "^19.0.0",
     "log-update": "^5.0.0",
+    "magic-string": "^0.25.7",
     "micromatch": "^4.0.4",
     "mlly": "^0.3.16",
     "nanoid": "^3.1.30",

package/dist/index-a190f5a1.js

@@ -1,352 +0,0 @@
-import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, s as suite, t as test, d as describe, i as it } from './suite-64b3e636.js';
-import chai, { util, assert, should, expect } from 'chai';
-import * as tinyspy from 'tinyspy';
-import { spies } from 'tinyspy';
-
-const beforeAll = (fn, timeout) => getCurrentSuite().on("beforeAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
-const afterAll = (fn, timeout) => getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
-const beforeEach = (fn, timeout) => getCurrentSuite().on("beforeEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
-const afterEach = (fn, timeout) => getCurrentSuite().on("afterEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
-
-function spyOn(obj, method, accessType) {
-  const dictionary = {
-    get: "getter",
-    set: "setter"
-  };
-  const objMethod = accessType ? { [dictionary[accessType]]: method } : method;
-  const stub = tinyspy.spyOn(obj, objMethod);
-  return enhanceSpy(stub);
-}
-function enhanceSpy(spy) {
-  const stub = spy;
-  let implementation;
-  const instances = [];
-  const mockContext = {
-    get calls() {
-      return stub.calls;
-    },
-    get instances() {
-      return instances;
-    },
-    get invocationCallOrder() {
-      return [];
-    },
-    get results() {
-      return stub.results.map(([callType, value]) => {
-        const type = callType === "error" ? "throw" : "return";
-        return { type, value };
-      });
-    }
-  };
-  let onceImplementations = [];
-  let name = "";
-  Object.defineProperty(stub, "name", {
-    get: () => name
-  });
-  stub.getMockName = () => name || "vi.fn()";
-  stub.mockName = (n) => {
-    name = n;
-    return stub;
-  };
-  stub.mockClear = () => {
-    stub.reset();
-    return stub;
-  };
-  stub.mockReset = () => {
-    stub.reset();
-    return stub;
-  };
-  stub.mockRestore = () => {
-    implementation = void 0;
-    onceImplementations = [];
-    stub.reset();
-    stub.restore();
-    return stub;
-  };
-  stub.getMockImplementation = () => implementation;
-  stub.mockImplementation = (fn2) => {
-    implementation = fn2;
-    return stub;
-  };
-  stub.mockImplementationOnce = (fn2) => {
-    onceImplementations.push(fn2);
-    return stub;
-  };
-  stub.mockReturnThis = () => stub.mockImplementation(function() {
-    return this;
-  });
-  stub.mockReturnValue = (val) => stub.mockImplementation(() => val);
-  stub.mockReturnValueOnce = (val) => stub.mockImplementationOnce(() => val);
-  stub.mockResolvedValue = (val) => stub.mockImplementation(() => Promise.resolve(val));
-  stub.mockResolvedValueOnce = (val) => stub.mockImplementationOnce(() => Promise.resolve(val));
-  stub.mockRejectedValue = (val) => stub.mockImplementation(() => Promise.reject(val));
-  stub.mockRejectedValueOnce = (val) => stub.mockImplementation(() => Promise.reject(val));
-  util.addProperty(stub, "mock", () => mockContext);
-  stub.willCall(function(...args) {
-    instances.push(this);
-    const impl = onceImplementations.shift() || implementation || stub.getOriginal() || (() => {
-    });
-    return impl.apply(this, args);
-  });
-  return stub;
-}
-function fn(implementation) {
-  return enhanceSpy(tinyspy.spyOn({ fn: implementation || (() => {
-  }) }, "fn"));
-}
-
-const originalSetTimeout = global.setTimeout;
-const originalSetInterval = global.setInterval;
-const originalClearTimeout = global.clearTimeout;
-const originalClearInterval = global.clearInterval;
-const MAX_LOOPS = 1e4;
-const assertEvery = (assertions, message) => {
-  if (assertions.some((a) => !a))
-    throw new Error(message);
-};
-const assertMaxLoop = (times) => {
-  if (times >= MAX_LOOPS)
-    throw new Error("setTimeout/setInterval called 10 000 times. It's possible it stuck in an infinite loop.");
-};
-const getNodeTimeout = (id) => {
-  const timer = {
-    ref: () => timer,
-    unref: () => timer,
-    hasRef: () => true,
-    refresh: () => timer,
-    [Symbol.toPrimitive]: () => id
-  };
-  return timer;
-};
-class FakeTimers {
-  constructor() {
-    this._advancedTime = 0;
-    this._nestedTime = {};
-    this._scopeId = 0;
-    this._isNested = false;
-    this._isOnlyPending = false;
-    this._spyid = 0;
-    this._isMocked = false;
-    this._tasksQueue = [];
-    this._queueCount = 0;
-  }
-  useFakeTimers() {
-    this._isMocked = true;
-    this.reset();
-    const spyFactory = (spyType, resultBuilder) => {
-      return (cb, ms = 0) => {
-        const id = ++this._spyid;
-        const nestedTo = Object.entries(this._nestedTime).filter(([key]) => Number(key) <= this._scopeId);
-        const nestedMs = nestedTo.reduce((total, [, ms2]) => total + ms2, ms);
-        const call = { id, cb, ms, nestedMs, scopeId: this._scopeId };
-        const task = { type: spyType, call, nested: this._isNested };
-        this.pushTask(task);
-        return resultBuilder(id, cb);
-      };
-    };
-    this._setTimeout = spyOn(global, "setTimeout").mockImplementation(spyFactory("timeout" /* Timeout */, getNodeTimeout));
-    this._setInterval = spyOn(global, "setInterval").mockImplementation(spyFactory("interval" /* Interval */, getNodeTimeout));
-    const clearTimerFactory = (spyType) => (id) => {
-      if (id === void 0)
-        return;
-      const index = this._tasksQueue.findIndex(({ call, type }) => type === spyType && call.id === Number(id));
-      if (index !== -1)
-        this._tasksQueue.splice(index, 1);
-    };
-    this._clearTimeout = spyOn(global, "clearTimeout").mockImplementation(clearTimerFactory("timeout" /* Timeout */));
-    this._clearInterval = spyOn(global, "clearInterval").mockImplementation(clearTimerFactory("interval" /* Interval */));
-  }
-  useRealTimers() {
-    this._isMocked = false;
-    this.reset();
-    global.setTimeout = originalSetTimeout;
-    global.setInterval = originalSetInterval;
-    global.clearTimeout = originalClearTimeout;
-    global.clearInterval = originalClearInterval;
-  }
-  runOnlyPendingTimers() {
-    this.assertMocked();
-    this._isOnlyPending = true;
-    this.runQueue();
-  }
-  runAllTimers() {
-    this.assertMocked();
-    this.runQueue();
-  }
-  advanceTimersByTime(ms) {
-    this.assertMocked();
-    this._advancedTime += ms;
-    this.runQueue();
-  }
-  advanceTimersToNextTimer() {
-    throw new Error("advanceTimersToNextTimer is not implemented");
-  }
-  runAllTicks() {
-    throw new Error("runAllTicks is not implemented");
-  }
-  setSystemTime(now) {
-    throw new Error("setSystemTime is not implemented");
-  }
-  getRealSystemTime() {
-    return Date.now();
-  }
-  getTimerCount() {
-    this.assertMocked();
-    return this._tasksQueue.length;
-  }
-  reset() {
-    var _a, _b, _c, _d;
-    this._advancedTime = 0;
-    this._nestedTime = {};
-    this._isNested = false;
-    this._isOnlyPending = false;
-    this._spyid = 0;
-    this._queueCount = 0;
-    this._tasksQueue = [];
-    (_a = this._clearInterval) == null ? void 0 : _a.mockRestore();
-    (_b = this._clearTimeout) == null ? void 0 : _b.mockRestore();
-    (_c = this._setInterval) == null ? void 0 : _c.mockRestore();
-    (_d = this._setTimeout) == null ? void 0 : _d.mockRestore();
-  }
-  runQueue() {
-    var _a, _b;
-    let index = 0;
-    while (this._tasksQueue[index]) {
-      assertMaxLoop(this._queueCount);
-      const task = this._tasksQueue[index];
-      const { call, nested, type } = task;
-      if (this._advancedTime && call.nestedMs > this._advancedTime)
-        break;
-      if (this._isOnlyPending && nested) {
-        index++;
-        continue;
-      }
-      this._scopeId = call.id;
-      this._isNested = true;
-      (_a = this._nestedTime)[_b = call.id] ?? (_a[_b] = 0);
-      this._nestedTime[call.id] += call.ms;
-      if (type === "timeout") {
-        this.removeTask(index);
-      } else if (type === "interval") {
-        call.nestedMs += call.ms;
-        const nestedMs = call.nestedMs;
-        const closestTask = this._tasksQueue.findIndex(({ type: type2, call: call2 }) => type2 === "interval" && call2.nestedMs < nestedMs);
-        if (closestTask !== -1 && closestTask !== index)
-          this.ensureQueueOrder();
-      }
-      call.cb();
-      this._queueCount++;
-    }
-  }
-  removeTask(index) {
-    if (index === 0)
-      this._tasksQueue.shift();
-    else
-      this._tasksQueue.splice(index, 1);
-  }
-  pushTask(task) {
-    this._tasksQueue.push(task);
-    this.ensureQueueOrder();
-  }
-  ensureQueueOrder() {
-    this._tasksQueue.sort((t1, t2) => {
-      const diff = t1.call.nestedMs - t2.call.nestedMs;
-      if (diff === 0) {
-        if (t1.type === "immediate" /* Immediate */ && t2.type !== "immediate" /* Immediate */)
-          return 1;
-        return 0;
-      }
-      return diff;
-    });
-  }
-  assertMocked() {
-    assertEvery([
-      this._isMocked,
-      this._setTimeout,
-      this._setInterval,
-      this._clearTimeout,
-      this._clearInterval
-    ], 'timers are not mocked. try calling "vitest.useFakeTimers()" first');
-  }
-}
-
-class VitestUtils {
-  constructor() {
-    this.spyOn = spyOn;
-    this.fn = fn;
-    this.mock = (path) => path;
-    this._timers = new FakeTimers();
-  }
-  useFakeTimers() {
-    return this._timers.useFakeTimers();
-  }
-  useRealTimers() {
-    return this._timers.useRealTimers();
-  }
-  runOnlyPendingTimers() {
-    return this._timers.runOnlyPendingTimers();
-  }
-  runAllTimers() {
-    return this._timers.runAllTimers();
-  }
-  advanceTimersByTime(ms) {
-    return this._timers.advanceTimersByTime(ms);
-  }
-  advanceTimersToNextTimer() {
-    return this._timers.advanceTimersToNextTimer();
-  }
-  runAllTicks() {
-    return this._timers.runAllTicks();
-  }
-  setSystemTime(time) {
-    return this._timers.setSystemTime(time);
-  }
-  getRealSystemTime() {
-    return this._timers.getRealSystemTime();
-  }
-  getTimerCount() {
-    return this._timers.getTimerCount();
-  }
-  isMockFunction(fn2) {
-    return typeof fn2 === "function" && "__isSpy" in fn2 && fn2.__isSpy;
-  }
-  clearAllMocks() {
-    spies.forEach((spy) => {
-      spy.reset();
-    });
-  }
-  resetAllMocks() {
-    spies.forEach((spy) => {
-      spy.reset();
-    });
-  }
-  restoreAllMocks() {
-    spies.forEach((spy) => {
-      spy.restore();
-    });
-  }
-}
-const vitest = new VitestUtils();
-const vi = vitest;
-
-var index = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  suite: suite,
-  test: test,
-  describe: describe,
-  it: it,
-  beforeAll: beforeAll,
-  afterAll: afterAll,
-  beforeEach: beforeEach,
-  afterEach: afterEach,
-  assert: assert,
-  should: should,
-  expect: expect,
-  chai: chai,
-  spyOn: spyOn,
-  fn: fn,
-  vitest: vitest,
-  vi: vi
-});
-
-export { afterAll as a, beforeAll as b, beforeEach as c, afterEach as d, vi as e, fn as f, index as i, spyOn as s, vitest as v };