vitest 0.0.84 → 0.0.89

package/dist/{index-ad1b10e4.js → index-733e7378.js}

@@ -3,17 +3,16 @@ import { createServer, mergeConfig } from 'vite';
 import process$2 from 'process';
 import { promises } from 'fs';
 import { d as defaultInclude, a as defaultExclude, b as defaultPort, c as distDir, e as configFiles } from './constants-adef7ffb.js';
-import { g as getNames, s as slash, a as getTests, b as getSuites, t as toArray, h as hasFailed } from './utils-9dcc4050.js';
+import { c, g as getNames, s as slash, a as getTests, b as getSuites, t as toArray, h as hasFailed } from './utils-385e2d09.js';
 import { performance } from 'perf_hooks';
-import { s as stringWidth, a as ansiStyles, b as stripAnsi, d as sliceAnsi, c, F as F_POINTER, e as F_DOWN, f as F_LONG_DASH, g as F_DOWN_RIGHT, h as F_DOT, i as F_CHECK, j as F_CROSS, k as cliTruncate, l as F_RIGHT, p as printError } from './error-c651f5ae.js';
-import require$$0 from 'assert';
+import { s as stringWidth, a as ansiStyles, b as stripAnsi, c as sliceAnsi, F as F_POINTER, d as F_DOWN, e as F_LONG_DASH, f as F_DOWN_RIGHT, g as F_DOT, h as F_CHECK, i as F_CROSS, j as cliTruncate, k as F_RIGHT, p as printError } from './error-309196c9.js';
+import assert$1 from 'assert';
 import require$$2 from 'events';
 import { MessageChannel } from 'worker_threads';
 import { pathToFileURL } from 'url';
 import Piscina from 'piscina';
 import fg from 'fast-glob';
 import mm from 'micromatch';
-import readline from 'readline';
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -644,7 +643,7 @@ const processOk = function (process) {
 if (!processOk(process$1)) {
   signalExit$1.exports = function () {};
 } else {
-  var assert = require$$0;
+  var assert = assert$1;
   var signals = signals$1.exports;
   var isWin = /^win/i.test(process$1.platform);
 
@@ -1157,8 +1156,8 @@ createLogUpdate(process$2.stderr);
 
 const DURATION_LONG = 300;
 const MAX_HEIGHT = 20;
-const spinnerMap = new WeakMap();
-const outputMap = new WeakMap();
+const spinnerMap = /* @__PURE__ */ new WeakMap();
+const outputMap = /* @__PURE__ */ new WeakMap();
 const pointer = c.yellow(F_POINTER);
 const skipped = c.yellow(F_DOWN);
 function divider(text, left, right) {
@@ -1414,7 +1413,7 @@ class ConsoleReporter {
       for (const suite of failedSuites) {
         this.error(c.red(`
 - ${getFullName(suite)}`));
-        await printError((_a = suite.result) == null ? void 0 : _a.error);
+        await printError((_a = suite.result) == null ? void 0 : _a.error, this.ctx);
         errorDivider();
       }
     }
@@ -1423,7 +1422,7 @@ class ConsoleReporter {
       this.error();
       for (const test of failedTests) {
         this.error(`${c.red(c.bold(c.inverse(" FAIL ")))} ${getFullName(test)}`);
-        await printError((_b = test.result) == null ? void 0 : _b.error);
+        await printError((_b = test.result) == null ? void 0 : _b.error, this.ctx);
         errorDivider();
       }
     }
@@ -1490,13 +1489,17 @@ ${c.bold(c.inverse(c.green(" PASS ")))}${c.green(" Waiting for file changes...")
     process[log.type].write(`${log.content}
 `);
   }
+  onServerRestart() {
+    this.console.clear();
+    this.log(c.cyan("Restarted due to config changes..."));
+  }
 }
 
 class StateManager {
   constructor() {
     this.filesMap = {};
     this.idMap = {};
-    this.taskFileMap = new WeakMap();
+    this.taskFileMap = /* @__PURE__ */ new WeakMap();
   }
   getFiles(keys) {
     if (keys)
@@ -1553,8 +1556,8 @@ function resolveConfig(options, viteConfig) {
   const resolved = __spreadProps(__spreadValues(__spreadValues({}, options), viteConfig.test), {
     root: viteConfig.root
   });
-  resolved.depsInline = ((_a = resolved.deps) == null ? void 0 : _a.inline) || [];
-  resolved.depsExternal = ((_b = resolved.deps) == null ? void 0 : _b.external) || [];
+  resolved.depsInline = [...((_a = resolved.deps) == null ? void 0 : _a.inline) || []];
+  resolved.depsExternal = [...((_b = resolved.deps) == null ? void 0 : _b.external) || []];
   resolved.environment = resolved.environment || "node";
   resolved.threads = resolved.threads ?? true;
   resolved.interpretDefault = resolved.interpretDefault ?? true;
@@ -1576,14 +1579,29 @@ function resolveConfig(options, viteConfig) {
 }
 
 async function transformRequest(server, id) {
+  let result = null;
   if (id.match(/\.(?:[cm]?[jt]sx?|json)$/)) {
-    return await server.transformRequest(id, { ssr: true });
+    result = await server.transformRequest(id, { ssr: true });
   } else {
-    const result = await server.transformRequest(id);
-    if (!result)
-      return void 0;
-    return await server.ssrTransform(result.code, result.map, id);
+    result = await server.transformRequest(id);
+    if (result)
+      result = await server.ssrTransform(result.code, result.map, id);
   }
+  if (result && process.env.NODE_V8_COVERAGE)
+    withInlineSourcemap(result);
+  return result;
+}
+let SOURCEMAPPING_URL = "sourceMa";
+SOURCEMAPPING_URL += "ppingURL";
+async function withInlineSourcemap(result) {
+  const { code, map } = result;
+  if (code.includes(`${SOURCEMAPPING_URL}=`))
+    return result;
+  if (map)
+    result.code = `${code}
+
+//# ${SOURCEMAPPING_URL}=data:application/json;charset=utf-8;base64,${Buffer.from(JSON.stringify(map), "utf-8").toString("base64")}`;
+  return result;
 }
 
 function createPool(ctx) {
@@ -1594,21 +1612,24 @@ function createPool(ctx) {
 }
 const workerPath = new URL("./dist/worker.js", pathToFileURL(distDir)).href;
 function createFakePool(ctx) {
-  const runTestFiles = async (files, invalidates) => {
-    const { default: run } = await import(workerPath);
-    const { workerPort, port } = createChannel(ctx);
-    const data = {
-      port: workerPort,
-      config: ctx.config,
-      files,
-      invalidates
+  const runWithFiles = (name) => {
+    return async (files, invalidates) => {
+      const worker = await import(workerPath);
+      const { workerPort, port } = createChannel(ctx);
+      const data = {
+        port: workerPort,
+        config: ctx.config,
+        files,
+        invalidates
+      };
+      await worker[name](data, { transferList: [workerPort] });
+      port.close();
+      workerPort.close();
     };
-    await run(data, { transferList: [workerPort] });
-    port.close();
-    workerPort.close();
   };
   return {
-    runTestFiles,
+    runTests: runWithFiles("run"),
+    collectTests: runWithFiles("collect"),
     close: async () => {
     }
   };
@@ -1623,22 +1644,25 @@ function createWorkerPool(ctx) {
   if (ctx.config.minThreads != null)
     options.minThreads = ctx.config.minThreads;
   const piscina = new Piscina(options);
-  const runTestFiles = async (files, invalidates) => {
-    await Promise.all(files.map(async (file) => {
-      const { workerPort, port } = createChannel(ctx);
-      const data = {
-        port: workerPort,
-        config: ctx.config,
-        files: [file],
-        invalidates
-      };
-      await piscina.run(data, { transferList: [workerPort] });
-      port.close();
-      workerPort.close();
-    }));
+  const runWithFiles = (name) => {
+    return async (files, invalidates) => {
+      await Promise.all(files.map(async (file) => {
+        const { workerPort, port } = createChannel(ctx);
+        const data = {
+          port: workerPort,
+          config: ctx.config,
+          files: [file],
+          invalidates
+        };
+        await piscina.run(data, { transferList: [workerPort], name });
+        port.close();
+        workerPort.close();
+      }));
+    };
   };
   return {
-    runTestFiles,
+    runTests: runWithFiles("run"),
+    collectTests: runWithFiles("collect"),
     close: () => piscina.destroy()
   };
 }
@@ -1661,7 +1685,7 @@ function createChannel(ctx) {
       case "snapshotSaved":
         return send(() => ctx.snapshot.add(args[0]));
       case "fetch":
-        return send(() => transformRequest(ctx.server, ...args));
+        return send(() => transformRequest(ctx.server, ...args).then((r) => r == null ? void 0 : r.code));
       case "onCollected":
         ctx.state.collectFiles(args[0]);
         ctx.reporters.forEach((r) => {
@@ -1693,138 +1717,129 @@ function isTargetFile(id, config) {
     return false;
   return mm.isMatch(id, config.include);
 }
-async function globTestFiles(config) {
-  return await fg(config.include, {
+async function globTestFiles(config, filters) {
+  let files = await fg(config.include, {
     absolute: true,
     cwd: config.root,
     ignore: config.exclude
   });
+  if (filters == null ? void 0 : filters.length)
+    files = files.filter((i) => filters.some((f) => i.includes(f)));
+  return files;
 }
 
-const WATCHER_DEBOUNCE = 50;
-async function startWatcher(ctx) {
-  const { server } = ctx;
-  ctx.reporters.forEach((r) => {
-    var _a;
-    return (_a = r.onWatcherStart) == null ? void 0 : _a.call(r);
-  });
-  let timer;
-  const changedTests = new Set();
-  const seen = new Set();
-  let isFirstRun = true;
-  let promise;
-  server.watcher.on("change", (id) => {
-    id = slash(id);
-    getAffectedTests(ctx, id, changedTests, seen);
-    if (changedTests.size === 0)
-      return;
-    rerunFile(id);
-  });
-  server.watcher.on("unlink", (id) => {
-    id = slash(id);
-    seen.add(id);
-    if (id in ctx.state.filesMap) {
-      delete ctx.state.filesMap[id];
-      changedTests.delete(id);
-    }
-  });
-  server.watcher.on("add", async (id) => {
-    id = slash(id);
-    if (isTargetFile(id, ctx.config)) {
-      changedTests.add(id);
-      rerunFile(id);
-    }
-  });
-  async function rerunFile(id) {
-    await promise;
-    clearTimeout(timer);
-    timer = setTimeout(async () => {
-      if (changedTests.size === 0) {
-        seen.clear();
-        return;
-      }
-      isFirstRun = false;
-      const invalidates = Array.from(seen);
-      const tests = Array.from(changedTests);
-      changedTests.clear();
-      seen.clear();
-      promise = start(tests, id, invalidates).then(() => {
-        promise = void 0;
-      });
-      await promise;
-    }, WATCHER_DEBOUNCE);
+const WATCHER_DEBOUNCE = 100;
+class Vitest {
+  constructor() {
+    this.config = void 0;
+    this.server = void 0;
+    this.state = void 0;
+    this.snapshot = void 0;
+    this.reporters = void 0;
+    this.invalidates = /* @__PURE__ */ new Set();
+    this.changedTests = /* @__PURE__ */ new Set();
+    this.isFirstRun = true;
+    this.console = globalThis.console;
   }
-  async function start(tests, id, invalidates) {
+  setServer(options, server) {
     var _a;
-    await ctx.report("onWatcherRerun", tests, id);
-    await ((_a = ctx.pool) == null ? void 0 : _a.runTestFiles(tests, invalidates));
-    await ctx.report("onFinished", ctx.state.getFiles(tests));
-    await ctx.report("onWatcherStart");
-  }
-  if (process.stdin.isTTY) {
-    readline.emitKeypressEvents(process.stdin);
-    process.stdin.setRawMode(true);
-    process.stdin.on("keypress", (str) => {
-      if (str === "" || str === "")
-        process.exit();
-      if (promise)
-        return;
-      if (isFirstRun)
-        process.exit();
-    });
-  }
-  await new Promise(() => {
-  });
-}
-function getAffectedTests(ctx, id, set = new Set(), seen = new Set()) {
-  if (seen.has(id) || set.has(id) || id.includes("/node_modules/") || id.includes("/vitest/dist/"))
-    return set;
-  seen.add(id);
-  if (id in ctx.state.filesMap) {
-    set.add(id);
-    return set;
-  }
-  const mod = ctx.server.moduleGraph.getModuleById(id);
-  if (mod) {
-    mod.importers.forEach((i) => {
-      if (i.id)
-        getAffectedTests(ctx, i.id, set, seen);
-    });
-  }
-  return set;
-}
-
-class Vitest {
-  constructor(options, server) {
+    (_a = this.pool) == null ? void 0 : _a.close();
+    this.pool = void 0;
     const resolved = resolveConfig(options, server.config);
     this.server = server;
     this.config = resolved;
     this.state = new StateManager();
     this.snapshot = new SnapshotManager(resolved);
     this.reporters = toArray(resolved.reporters);
-    this.console = globalThis.console;
     if (!this.reporters.length)
       this.reporters.push(new ConsoleReporter(this));
+    if (this.config.watch)
+      this.registerWatcher();
+    this.runningPromise = void 0;
   }
-  async run(filters) {
-    let testFilepaths = await globTestFiles(this.config);
-    if (filters == null ? void 0 : filters.length)
-      testFilepaths = testFilepaths.filter((i) => filters.some((f) => i.includes(f)));
-    if (!testFilepaths.length) {
+  async start(filters) {
+    const files = await globTestFiles(this.config, filters);
+    if (!files.length) {
       console.error("No test files found");
       process.exitCode = 1;
+    }
+    await this.runFiles(files);
+    if (this.config.watch) {
+      await this.report("onWatcherStart");
+      await new Promise(() => {
+      });
+    }
+  }
+  async runFiles(files) {
+    await this.runningPromise;
+    this.runningPromise = (async () => {
+      if (!this.pool)
+        this.pool = createPool(this);
+      const invalidates = Array.from(this.invalidates);
+      this.invalidates.clear();
+      await this.pool.runTests(files, invalidates);
+      if (hasFailed(this.state.getFiles()))
+        process.exitCode = 1;
+      await this.report("onFinished", this.state.getFiles());
+    })().finally(() => {
+      this.runningPromise = void 0;
+    });
+    return await this.runningPromise;
+  }
+  registerWatcher() {
+    let timer;
+    const scheduleRerun = async (id) => {
+      await this.runningPromise;
+      clearTimeout(timer);
+      timer = setTimeout(async () => {
+        if (this.changedTests.size === 0) {
+          this.invalidates.clear();
+          return;
+        }
+        this.isFirstRun = false;
+        const files = Array.from(this.changedTests);
+        await this.report("onWatcherRerun", files, id);
+        await this.runFiles(files);
+        await this.report("onWatcherStart");
+      }, WATCHER_DEBOUNCE);
+    };
+    this.server.watcher.on("change", (id) => {
+      id = slash(id);
+      this.handleFileChanged(id);
+      if (this.changedTests.size)
+        scheduleRerun(id);
+    });
+    this.server.watcher.on("unlink", (id) => {
+      id = slash(id);
+      this.invalidates.add(id);
+      if (id in this.state.filesMap) {
+        delete this.state.filesMap[id];
+        this.changedTests.delete(id);
+      }
+    });
+    this.server.watcher.on("add", async (id) => {
+      id = slash(id);
+      if (isTargetFile(id, this.config)) {
+        this.changedTests.add(id);
+        scheduleRerun(id);
+      }
+    });
+  }
+  handleFileChanged(id) {
+    if (this.changedTests.has(id) || this.invalidates.has(id) || id.includes("/node_modules/") || id.includes("/vitest/dist/"))
+      return;
+    this.invalidates.add(id);
+    if (id in this.state.filesMap) {
+      this.changedTests.add(id);
       return;
     }
-    if (!this.pool)
-      this.pool = createPool(this);
-    await this.pool.runTestFiles(testFilepaths);
-    if (hasFailed(this.state.getFiles()))
-      process.exitCode = 1;
-    await this.report("onFinished", this.state.getFiles());
-    if (this.config.watch)
-      await startWatcher(this);
-    else
-      await this.pool.close();
+    const mod = this.server.moduleGraph.getModuleById(id);
+    if (mod) {
+      mod.importers.forEach((i) => {
+        if (i.id)
+          this.handleFileChanged(i.id);
+      });
+    }
   }
   async close() {
     var _a;
@@ -1838,14 +1853,11 @@ class Vitest {
     }));
   }
 }
-async function createVitest(options, viteOverrides) {
-  const server = await startServer(options, viteOverrides);
-  const instance = new Vitest(options, server);
-  return instance;
-}
-async function startServer(options, viteOverrides = {}) {
+async function createVitest(options, viteOverrides = {}) {
+  const ctx = new Vitest();
   const root = resolve(options.root || process.cwd());
   const configPath = options.config ? resolve(root, options.config) : await findUp(configFiles, { cwd: root });
+  let haveStarted = false;
   const config = {
     root,
     logLevel: "error",
@@ -1855,6 +1867,10 @@ async function startServer(options, viteOverrides = {}) {
       {
         name: "vitest",
         async configureServer(server2) {
+          if (haveStarted)
+            await ctx.report("onServerRestart");
+          ctx.setServer(options, server2);
+          haveStarted = true;
           if (options.api)
             server2.middlewares.use((await import('./middleware-650c5fa0.js')).default());
         }
@@ -1874,7 +1890,7 @@ async function startServer(options, viteOverrides = {}) {
   await server.pluginContainer.buildStart({});
   if (typeof options.api === "number")
     await server.listen(options.api);
-  return server;
+  return ctx;
 }
 
 export { createVitest as c };

package/dist/index.d.ts

@@ -1,9 +1,7 @@
 import { Formatter } from 'picocolors/types';
-import { TransformResult } from 'vite';
 import { OptionsReceived } from 'pretty-format';
 import { MessagePort } from 'worker_threads';
 export { assert, default as chai, expect, should } from 'chai';
-import { spyOn, spy } from 'tinyspy';
 export { spy, spyOn } from 'tinyspy';
 
 declare const EXPECTED_COLOR: Formatter;
@@ -117,7 +115,7 @@ declare type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
 interface ModuleCache {
     promise?: Promise<any>;
     exports?: any;
-    transformResult?: TransformResult;
+    code?: string;
 }
 interface EnvironmentReturn {
     teardown: (global: any) => Awaitable<void>;
@@ -221,6 +219,7 @@ interface Reporter {
     onTaskUpdate?: (pack: TaskResultPack) => Awaitable<void>;
     onWatcherStart?: () => Awaitable<void>;
     onWatcherRerun?: (files: string[], trigger: string) => Awaitable<void>;
+    onServerRestart?: () => Awaitable<void>;
     onUserConsoleLog?: (log: UserConsoleLog) => Awaitable<void>;
 }
 
@@ -420,7 +419,7 @@ interface WorkerContext {
     invalidates?: string[];
 }
 interface RpcMap {
-    fetch: [[id: string], TransformResult | null | undefined];
+    fetch: [[id: string], string | undefined];
     log: [[UserConsoleLog], void];
     processExit: [[code?: number], void];
     onCollected: [[files: File[]], void];
@@ -541,9 +540,54 @@ declare const afterAll: (fn: SuiteHooks['afterAll'][0], timeout?: number | undef
 declare const beforeEach: (fn: SuiteHooks['beforeEach'][0], timeout?: number | undefined) => void;
 declare const afterEach: (fn: SuiteHooks['afterEach'][0], timeout?: number | undefined) => void;
 
+interface MockResultReturn<T> {
+    type: 'return';
+    value: T;
+}
+interface MockResultIncomplete {
+    type: 'incomplete';
+    value: undefined;
+}
+interface MockResultThrow {
+    type: 'throw';
+    value: any;
+}
+declare type MockResult<T> = MockResultReturn<T> | MockResultThrow | MockResultIncomplete;
+interface JestMockCompatContext<T, Y> {
+    calls: Y[];
+    instances: T[];
+    invocationCallOrder: number[];
+    results: MockResult<T>[];
+}
+interface JestMockCompat<TArgs extends any[] = any[], TReturns = any> {
+    getMockName(): string;
+    mockName(n: string): this;
+    mock: JestMockCompatContext<TArgs, TReturns>;
+    mockClear(): this;
+    mockReset(): this;
+    mockRestore(): void;
+    getMockImplementation(): ((...args: TArgs) => TReturns) | undefined;
+    mockImplementation(fn: ((...args: TArgs) => TReturns) | (() => Promise<TReturns>)): this;
+    mockImplementationOnce(fn: ((...args: TArgs) => TReturns) | (() => Promise<TReturns>)): this;
+    mockReturnThis(): this;
+    mockReturnValue(obj: TReturns): this;
+    mockReturnValueOnce(obj: TReturns): this;
+    mockResolvedValue(obj: Unpromisify<TReturns>): this;
+    mockResolvedValueOnce(obj: Unpromisify<TReturns>): this;
+    mockRejectedValue(obj: any): this;
+    mockRejectedValueOnce(obj: any): this;
+}
+interface JestMockCompatFn<TArgs extends any[] = any, TReturns = any> extends JestMockCompat<TArgs, TReturns> {
+    (...args: TArgs): TReturns;
+}
+declare function spyOn<T, K extends keyof T>(obj: T, method: K, accessType?: 'get' | 'set'): T[K] extends (...args: infer TArgs) => infer TReturnValue ? JestMockCompat<TArgs, TReturnValue> : JestMockCompat;
+declare type Unpromisify<T> = T extends Promise<infer R> ? R : never;
+declare function fn<TArgs extends any[] = any[], R = any>(): JestMockCompatFn<TArgs, R>;
+declare function fn<TArgs extends any[] = any[], R = any>(implementation: (...args: TArgs) => R): JestMockCompatFn<TArgs, R>;
+
 declare const vitest: {
     spyOn: typeof spyOn;
-    fn: typeof spy;
+    fn: typeof fn;
 };
 
 declare module 'vite' {

package/dist/index.js

@@ -1,5 +1,5 @@
-export { d as describe, i as it, s as suite, t as test } from './suite-0e21bf9b.js';
-export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, v as vitest } from './index-906ac3f9.js';
+export { d as describe, i as it, s as suite, t as test } from './suite-b8c6cb53.js';
+export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, v as vitest } from './index-722fb5a5.js';
 export { assert, default as chai, expect, should } from 'chai';
 export { spy, spyOn } from 'tinyspy';
 import './index-9e71c815.js';

package/dist/node.js

@@ -1,14 +1,15 @@
-export { c as createVitest } from './index-ad1b10e4.js';
+export { c as createVitest } from './index-733e7378.js';
 import 'path';
 import 'vite';
 import 'process';
 import 'fs';
 import './constants-adef7ffb.js';
 import 'url';
-import './utils-9dcc4050.js';
-import 'perf_hooks';
-import './error-c651f5ae.js';
+import './utils-385e2d09.js';
+import 'module';
 import 'tty';
+import 'perf_hooks';
+import './error-309196c9.js';
 import 'source-map';
 import 'assert';
 import 'events';
@@ -16,4 +17,3 @@ import 'worker_threads';
 import 'piscina';
 import 'fast-glob';
 import 'micromatch';
-import 'readline';

package/dist/{suite-0e21bf9b.js → suite-b8c6cb53.js}

@@ -48,8 +48,8 @@ function normalizeTest(fn, timeout) {
   return withTimeout(ensureAsyncTest(fn), timeout);
 }
 
-const fnMap = new WeakMap();
-const hooksMap = new WeakMap();
+const fnMap = /* @__PURE__ */ new WeakMap();
+const hooksMap = /* @__PURE__ */ new WeakMap();
 function setFn(key, fn) {
   fnMap.set(key, fn);
 }