vitest 0.0.62 → 0.0.66

package/LICENSE

@@ -1,6 +1,7 @@
 MIT License
 
-Copyright (c) 2021 Anthony Fu <https://github.com/antfu>
+Copyright (c) 2021-Present Anthony Fu <https://github.com/antfu>
+Copyright (c) 2021-Present Matias Capeletto <https://github.com/patak-dev>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.gh.md

@@ -29,7 +29,7 @@ A blazing fast unit test framework powered by Vite.
 - [Smart & instant watch mode](#watch-mode), like HMR for tests!
 - [Native code coverage](#coverage) via [c8](https://github.com/bcoe/c8)
 - [Sinon](https://sinonjs.org/) built-in for mocking, stubbing, and spies.
-- [JSDOM](https://github.com/jsdom/jsdom) and [happy-dom](https://github.com/capricorn86/happy-dom) built-in for DOM and browser API mocking
+- [JSDOM](https://github.com/jsdom/jsdom) and [happy-dom](https://github.com/capricorn86/happy-dom) for DOM and browser API mocking
 - Components testing ([Vue](./test/vue), [React](./test/react), [Lit](./test/lit), [Vitesse](./test/vitesse))
 - Workers multi-threading via [Piscina](https://github.com/piscinajs/piscina)
 - ESM first, top level await
@@ -80,8 +80,8 @@ $ npx vitest
 
 - Create `vitest.config.ts`, which will have the higher priority
 - Pass `--config` option to CLI, e.g. `vitest --config ./path/to/vitest.config.ts`
-- Use `process.env.VITEST` to conditionally apply differnet configuration in `vite.config.ts`
-- Use `process.env.VITEST_MAX_THREADS` to limit amount of worker threads
+- Use `process.env.VITEST` to conditionally apply different configuration in `vite.config.ts`
+
 To configure `vitest` itself, add `test` property in your Vite config
 
 ```ts
@@ -142,20 +142,15 @@ export default defineConfig({
 
 ## Browser Mocking
 
-Pass `--dom` option in CLI to enable browser mocking. Or the `dom` flag in the config.
-
-```ts
-// vite.config.ts
-import { defineConfig } from 'vite'
+Vitest supports both [happy-dom](https://github.com/capricorn86/happy-dom) or [jsdom](https://github.com/jsdom/jsdom) for mocking DOM and browser APIs. They don't come with Vitest, you might need to install them:
 
-export default defineConfig({
-  test: {
-    dom: true
-  }
-})
+```bash
+$ npm i -D happy-dom
+# or
+$ npm i -D jsdom
 ```
 
-Vitest by default uses [jsdom](https://github.com/jsdom/jsdom) for mocking, but it also support [happy-dom](https://github.com/capricorn86/happy-dom), a faster alternative to jsdom. You can configure it with:
+After that, change the `environment` option in your config file:
 
 ```ts
 // vite.config.ts
@@ -163,7 +158,7 @@ import { defineConfig } from 'vite'
 
 export default defineConfig({
   test: {
-    dom: 'happy-dom'
+    environment: 'happy-dom' // or 'jsdom', 'node'
   }
 })
 ```
@@ -181,6 +176,7 @@ Vitest smartly searches the module graph and only rerun the related tests (just
 Vitest works perfectly with [c8](https://github.com/bcoe/c8)
 
 ```bash
+$ npm i -D c8
 $ c8 vitest
 ```
 

package/dist/chunk-5TNYWP3O.js

@@ -0,0 +1,81 @@
+import {
+  init_esm_shims
+} from "./chunk-R2SMNEBL.js";
+
+// src/utils.ts
+init_esm_shims();
+function toArray(array) {
+  array = array || [];
+  if (Array.isArray(array))
+    return array;
+  return [array];
+}
+function notNullish(v) {
+  return v != null;
+}
+function slash(str) {
+  return str.replace(/\\/g, "/");
+}
+function partitionSuiteChildren(suite) {
+  let tasksGroup = [];
+  const tasksGroups = [];
+  for (const c of suite.tasks) {
+    if (tasksGroup.length === 0 || c.computeMode === tasksGroup[0].computeMode) {
+      tasksGroup.push(c);
+    } else {
+      tasksGroups.push(tasksGroup);
+      tasksGroup = [c];
+    }
+  }
+  if (tasksGroup.length > 0)
+    tasksGroups.push(tasksGroup);
+  return tasksGroups;
+}
+function interpretOnlyMode(items) {
+  if (items.some((i) => i.mode === "only")) {
+    items.forEach((i) => {
+      if (i.mode === "run")
+        i.mode = "skip";
+      else if (i.mode === "only")
+        i.mode = "run";
+    });
+  }
+}
+function getTests(suite) {
+  return toArray(suite).flatMap((s) => s.tasks.flatMap((c) => c.type === "test" ? [c] : getTests(c)));
+}
+function getSuites(suite) {
+  return toArray(suite).flatMap((s) => s.type === "suite" ? [s, ...getSuites(s.tasks)] : []);
+}
+function hasTests(suite) {
+  return toArray(suite).some((s) => s.tasks.some((c) => c.type === "test" || hasTests(c)));
+}
+function hasFailed(suite) {
+  return toArray(suite).some((s) => {
+    var _a;
+    return ((_a = s.result) == null ? void 0 : _a.state) === "fail" || s.type === "suite" && hasFailed(s.tasks);
+  });
+}
+function getNames(task) {
+  const names = [task.name];
+  let current = task;
+  while ((current == null ? void 0 : current.suite) || (current == null ? void 0 : current.file)) {
+    current = current.suite || current.file;
+    if (current == null ? void 0 : current.name)
+      names.unshift(current.name);
+  }
+  return names;
+}
+
+export {
+  toArray,
+  notNullish,
+  slash,
+  partitionSuiteChildren,
+  interpretOnlyMode,
+  getTests,
+  getSuites,
+  hasTests,
+  hasFailed,
+  getNames
+};

package/dist/chunk-ANPMHBIF.js

@@ -0,0 +1,253 @@
+import {
+  nanoid
+} from "./chunk-APGELTDH.js";
+import {
+  init_esm_shims
+} from "./chunk-R2SMNEBL.js";
+
+// src/runtime/suite.ts
+init_esm_shims();
+
+// src/runtime/context.ts
+init_esm_shims();
+var context = {
+  tasks: [],
+  currentSuite: null
+};
+
+// src/runtime/map.ts
+init_esm_shims();
+var fnMap = new WeakMap();
+var hooksMap = 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);
+}
+
+// src/runtime/suite.ts
+var suite = createSuite();
+var defaultSuite = suite("");
+function getCurrentSuite() {
+  return context.currentSuite || defaultSuite;
+}
+var getDefaultTestTimeout = () => {
+  var _a, _b;
+  return ((_b = (_a = process.__vitest_worker__) == null ? void 0 : _a.config) == null ? void 0 : _b.testTimeout) ?? 5e3;
+};
+var getDefaultHookTimeout = () => {
+  var _a, _b;
+  return ((_b = (_a = process.__vitest_worker__) == null ? void 0 : _a.config) == null ? void 0 : _b.hookTimeout) ?? 5e3;
+};
+function createSuiteHooks() {
+  return {
+    beforeAll: [],
+    afterAll: [],
+    beforeEach: [],
+    afterEach: []
+  };
+}
+function createSuiteCollector(name, factory = () => {
+}, mode, suiteComputeMode) {
+  var _a;
+  const tasks = [];
+  const factoryQueue = [];
+  let suite2;
+  initSuite();
+  const test2 = createTestCollector((name2, fn, mode2, computeMode) => {
+    const test3 = {
+      id: nanoid(),
+      type: "test",
+      name: name2,
+      mode: mode2,
+      computeMode: computeMode ?? (suiteComputeMode ?? "serial"),
+      suite: void 0
+    };
+    setFn(test3, fn);
+    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) {
+      const prev = context.currentSuite;
+      context.currentSuite = collector;
+      await factory(test2);
+      context.currentSuite = prev;
+    }
+    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;
+  }
+  (_a = context.currentSuite) == null ? void 0 : _a.tasks.push(collector);
+  return collector;
+}
+function createTestCollector(collectTest) {
+  function test2(name, fn, timeout) {
+    collectTest(name, withTimeout(fn, timeout), "run");
+  }
+  test2.concurrent = concurrent;
+  test2.skip = skip;
+  test2.only = only;
+  test2.todo = todo;
+  function concurrent(name, fn, timeout) {
+    collectTest(name, withTimeout(fn, timeout), "run", "concurrent");
+  }
+  concurrent.skip = (name, fn, timeout) => collectTest(name, withTimeout(fn, timeout), "skip", "concurrent");
+  concurrent.only = (name, fn, timeout) => collectTest(name, withTimeout(fn, timeout), "only", "concurrent");
+  concurrent.todo = todo;
+  function skip(name, fn, timeout) {
+    collectTest(name, withTimeout(fn, timeout), "skip");
+  }
+  skip.concurrent = concurrent.skip;
+  function only(name, fn, timeout) {
+    collectTest(name, withTimeout(fn, timeout), "only");
+  }
+  only.concurrent = concurrent.only;
+  function todo(name) {
+    collectTest(name, () => {
+    }, "todo");
+  }
+  todo.concurrent = todo;
+  return test2;
+}
+var test = function() {
+  function test2(name, fn, timeout) {
+    return getCurrentSuite().test(name, fn, timeout);
+  }
+  function concurrent(name, fn, timeout) {
+    return getCurrentSuite().test.concurrent(name, fn, timeout);
+  }
+  concurrent.skip = (name, fn, timeout) => getCurrentSuite().test.concurrent.skip(name, fn, timeout);
+  concurrent.only = (name, fn, timeout) => getCurrentSuite().test.concurrent.only(name, fn, timeout);
+  concurrent.todo = (name) => getCurrentSuite().test.concurrent.todo(name);
+  function skip(name, fn, timeout) {
+    return getCurrentSuite().test.skip(name, fn, timeout);
+  }
+  skip.concurrent = (name, fn, timeout) => getCurrentSuite().test.skip.concurrent(name, fn, timeout);
+  function only(name, fn, timeout) {
+    return getCurrentSuite().test.only(name, fn, timeout);
+  }
+  only.concurrent = (name, fn, timeout) => getCurrentSuite().test.only.concurrent(name, fn, timeout);
+  function todo(name) {
+    return getCurrentSuite().test.todo(name);
+  }
+  todo.concurrent = (name) => getCurrentSuite().test.todo.concurrent(name);
+  test2.concurrent = concurrent;
+  test2.skip = skip;
+  test2.only = only;
+  test2.todo = todo;
+  return test2;
+}();
+function createSuite() {
+  function suite2(suiteName, factory) {
+    return createSuiteCollector(suiteName, factory, "run");
+  }
+  function concurrent(suiteName, factory) {
+    return createSuiteCollector(suiteName, factory, "run", "concurrent");
+  }
+  concurrent.skip = (suiteName, factory) => createSuiteCollector(suiteName, factory, "skip", "concurrent");
+  concurrent.only = (suiteName, factory) => createSuiteCollector(suiteName, factory, "only", "concurrent");
+  concurrent.todo = (suiteName) => createSuiteCollector(suiteName, void 0, "todo");
+  function skip(suiteName, factory) {
+    return createSuiteCollector(suiteName, factory, "skip");
+  }
+  skip.concurrent = concurrent.skip;
+  function only(suiteName, factory) {
+    return createSuiteCollector(suiteName, factory, "only");
+  }
+  only.concurrent = concurrent.only;
+  function todo(suiteName) {
+    return createSuiteCollector(suiteName, void 0, "todo");
+  }
+  todo.concurrent = concurrent.todo;
+  suite2.concurrent = concurrent;
+  suite2.skip = skip;
+  suite2.only = only;
+  suite2.todo = todo;
+  return suite2;
+}
+var describe = suite;
+var it = test;
+var beforeAll = (fn, timeout) => getCurrentSuite().on("beforeAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+var afterAll = (fn, timeout) => getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+var beforeEach = (fn, timeout) => getCurrentSuite().on("beforeEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+var afterEach = (fn, timeout) => getCurrentSuite().on("afterEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+function clearContext() {
+  context.tasks.length = 0;
+  defaultSuite.clear();
+  context.currentSuite = defaultSuite;
+}
+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();
+    })]);
+  };
+}
+
+export {
+  context,
+  getFn,
+  setHooks,
+  getHooks,
+  suite,
+  defaultSuite,
+  createSuiteHooks,
+  test,
+  describe,
+  it,
+  beforeAll,
+  afterAll,
+  beforeEach,
+  afterEach,
+  clearContext
+};

package/dist/chunk-APGELTDH.js

@@ -0,0 +1,19 @@
+import {
+  init_esm_shims
+} from "./chunk-R2SMNEBL.js";
+
+// node_modules/.pnpm/nanoid@3.1.30/node_modules/nanoid/non-secure/index.js
+init_esm_shims();
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+var nanoid = (size = 21) => {
+  let id = "";
+  let i = size;
+  while (i--) {
+    id += urlAlphabet[Math.random() * 64 | 0];
+  }
+  return id;
+};
+
+export {
+  nanoid
+};

package/dist/chunk-R2SMNEBL.js

@@ -0,0 +1,95 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+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));
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module, desc) => {
+  if (module && typeof module === "object" || typeof module === "function") {
+    for (let key of __getOwnPropNames(module))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module) => {
+  return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateWrapper = (obj, member, setter, getter) => {
+  return {
+    set _(value) {
+      __privateSet(obj, member, value, setter);
+    },
+    get _() {
+      return __privateGet(obj, member, getter);
+    }
+  };
+};
+
+// node_modules/.pnpm/tsup@5.11.1_typescript@4.5.3/node_modules/tsup/assets/esm_shims.js
+import { fileURLToPath } from "url";
+import path from "path";
+var init_esm_shims = __esm({
+  "node_modules/.pnpm/tsup@5.11.1_typescript@4.5.3/node_modules/tsup/assets/esm_shims.js"() {
+  }
+});
+
+export {
+  __spreadValues,
+  __spreadProps,
+  __commonJS,
+  __export,
+  __toModule,
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateWrapper,
+  init_esm_shims
+};

package/dist/chunk-VLGIKNLC.js

@@ -0,0 +1,78 @@
+import {
+  init_esm_shims
+} from "./chunk-R2SMNEBL.js";
+
+// src/integrations/snapshot/port/jest-test-result-helper.ts
+init_esm_shims();
+var emptySummary = (options) => {
+  const summary = {
+    added: 0,
+    failure: false,
+    filesAdded: 0,
+    filesRemoved: 0,
+    filesRemovedList: [],
+    filesUnmatched: 0,
+    filesUpdated: 0,
+    matched: 0,
+    total: 0,
+    unchecked: 0,
+    uncheckedKeysByFile: [],
+    unmatched: 0,
+    updated: 0,
+    didUpdate: options.updateSnapshot === "all"
+  };
+  return summary;
+};
+var packSnapshotState = (filepath, state) => {
+  const snapshot = {
+    filepath,
+    added: 0,
+    fileDeleted: false,
+    matched: 0,
+    unchecked: 0,
+    uncheckedKeys: [],
+    unmatched: 0,
+    updated: 0
+  };
+  const uncheckedCount = state.getUncheckedCount();
+  const uncheckedKeys = state.getUncheckedKeys();
+  if (uncheckedCount)
+    state.removeUncheckedKeys();
+  const status = state.save();
+  snapshot.fileDeleted = status.deleted;
+  snapshot.added = state.added;
+  snapshot.matched = state.matched;
+  snapshot.unmatched = state.unmatched;
+  snapshot.updated = state.updated;
+  snapshot.unchecked = !status.deleted ? uncheckedCount : 0;
+  snapshot.uncheckedKeys = Array.from(uncheckedKeys);
+  return snapshot;
+};
+var addSnapshotResult = (summary, result) => {
+  if (result.added)
+    summary.filesAdded++;
+  if (result.fileDeleted)
+    summary.filesRemoved++;
+  if (result.unmatched)
+    summary.filesUnmatched++;
+  if (result.updated)
+    summary.filesUpdated++;
+  summary.added += result.added;
+  summary.matched += result.matched;
+  summary.unchecked += result.unchecked;
+  if (result.uncheckedKeys && result.uncheckedKeys.length > 0) {
+    summary.uncheckedKeysByFile.push({
+      filePath: result.filepath,
+      keys: result.uncheckedKeys
+    });
+  }
+  summary.unmatched += result.unmatched;
+  summary.updated += result.updated;
+  summary.total += result.added + result.matched + result.unmatched + result.updated;
+};
+
+export {
+  emptySummary,
+  packSnapshotState,
+  addSnapshotResult
+};

package/dist/chunk-XUIDSY4V.js

@@ -0,0 +1,35 @@
+import {
+  init_esm_shims
+} from "./chunk-R2SMNEBL.js";
+
+// src/constants.ts
+init_esm_shims();
+import { resolve } from "path";
+import { fileURLToPath } from "url";
+var distDir = resolve(fileURLToPath(import.meta.url), "../../dist");
+var defaultIncludes = ["**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"];
+var defaultExcludes = ["**/node_modules/**", "**/dist/**"];
+var globalApis = [
+  "suite",
+  "test",
+  "describe",
+  "it",
+  "chai",
+  "expect",
+  "assert",
+  "sinon",
+  "spy",
+  "mock",
+  "stub",
+  "beforeAll",
+  "afterAll",
+  "beforeEach",
+  "afterEach"
+];
+
+export {
+  distDir,
+  defaultIncludes,
+  defaultExcludes,
+  globalApis
+};