vitest 0.0.91 → 0.0.95

package/bin/vitest.mjs

@@ -2,12 +2,16 @@
 
 import { fileURLToPath } from 'url'
 import { resolve } from 'path'
-import { checkPeerDependency } from '../dist/utils.js'
+import { ensurePackageInstalled } from '../dist/utils.js'
 
 const argv = process.argv.slice(2)
 
+if (!await ensurePackageInstalled('vite'))
+  process.exit(1)
+
 if (argv.includes('--coverage')) {
-  checkPeerDependency('c8/bin/c8.js')
+  if (!await ensurePackageInstalled('c8'))
+    process.exit(1)
   const filename = fileURLToPath(import.meta.url)
   const entry = resolve(filename, '../../dist/cli.js')
   process.argv.splice(2, 0, process.argv[0], entry)

package/dist/cli.js

@@ -1,23 +1,24 @@
-import readline from 'readline';
+import require$$0 from 'readline';
 import { EventEmitter } from 'events';
-import { c } from './utils-5d0cec8a.js';
-import { c as createVitest } from './index-25bef3dd.js';
-import 'module';
+import { c, e as ensurePackageInstalled } from './utils-576876dc.js';
+import { c as createVitest } from './index-ece64e3c.js';
 import 'tty';
+import 'local-pkg';
 import 'path';
 import 'vite';
 import 'process';
 import 'fs';
+import 'fast-glob';
+import 'util';
 import './constants-9cfa4d7b.js';
 import 'url';
 import 'perf_hooks';
-import './error-abd1f726.js';
+import './error-81292c96.js';
 import 'source-map';
+import './index-5cc247ff.js';
 import 'assert';
 import 'worker_threads';
-import 'piscina';
-import 'fast-glob';
-import 'micromatch';
+import 'tinypool';
 
 function toArr(any) {
 	return any == null ? [] : Array.isArray(any) ? any : [any];
@@ -632,7 +633,7 @@ class CAC extends EventEmitter {
 
 const cac = (name = "") => new CAC(name);
 
-var version = "0.0.91";
+var version = "0.0.95";
 
 const cli = cac("vitest");
 cli.version(version).option("-r, --root <path>", "root path").option("-c, --config <path>", "path to config file").option("-u, --update", "update snapshot").option("-w, --watch", "watch mode").option("-o, --open", "open Vitest UI").option("--api", "listen to port and serve API").option("--threads", "enabled threads", { default: true }).option("--silent", "silent").option("--global", "inject apis globally").option("--dom", "mock browser api with happy-dom").option("--environment <env>", "runner environment", {
@@ -653,12 +654,18 @@ async function run(cliFilters, options) {
   process.env.NODE_ENV = "test";
   if (!options.silent) {
     console.log(c.magenta(c.bold("\nVitest is in closed beta exclusively for Sponsors")));
-    console.log(c.yellow("Learn more at https://vitest.dev\n"));
+    console.log(c.yellow("Learn more at https://vitest.dev"));
   }
   const ctx = await createVitest(options);
-  process.__vitest__ = ctx;
   process.chdir(ctx.config.root);
   registerConsoleShortcuts(ctx);
+  if (ctx.config.environment && ctx.config.environment !== "node") {
+    if (!await ensurePackageInstalled(ctx.config.environment))
+      process.exit(1);
+  }
+  ctx.onServerRestarted(() => {
+    ctx.start(cliFilters);
+  });
   try {
     await ctx.start(cliFilters);
   } catch (e) {
@@ -671,7 +678,7 @@ async function run(cliFilters, options) {
 }
 function registerConsoleShortcuts(ctx) {
   if (process.stdin.isTTY) {
-    readline.emitKeypressEvents(process.stdin);
+    require$$0.emitKeypressEvents(process.stdin);
     process.stdin.setRawMode(true);
     process.stdin.on("keypress", (str) => {
       if (str === "" || str === "")

package/dist/entry.js

@@ -1,3 +1,4 @@
+import fs, { promises } from 'fs';
 import { Console } from 'console';
 import { Writable } from 'stream';
 import { importModule } from 'local-pkg';
@@ -5,13 +6,12 @@ import chai, { expect, util } from 'chai';
 import Subset from 'chai-subset';
 import path, { basename } from 'path';
 import { r as rpc, s as send } from './rpc-7de86f29.js';
-import { g as getNames, c as c$1, t as toArray, i as interpretOnlyMode, p as partitionSuiteChildren, d as hasTests, h as hasFailed } from './utils-5d0cec8a.js';
-import fs from 'fs';
-import { u as unifiedDiff } from './error-abd1f726.js';
+import { g as getNames, c as c$1, t as toArray, i as interpretOnlyMode, p as partitionSuiteChildren, f as hasTests, h as hasFailed } from './utils-576876dc.js';
+import { u as unifiedDiff } from './error-81292c96.js';
 import { performance } from 'perf_hooks';
 import { b as setHooks, c as createSuiteHooks, e as clearContext, f as defaultSuite, h as context, j as getHooks, k as getFn } from './suite-b8c6cb53.js';
 import { n as nanoid } from './index-9e71c815.js';
-import 'module';
+import { format as format$1 } from 'util';
 import 'tty';
 import 'source-map';
 
@@ -3414,7 +3414,7 @@ const JestChaiExpect = (chai, utils) => {
       const expected = args[0];
       const actual = utils.flag(this, "object");
       if (hasAsymmetric(expected)) {
-        this.assert(equals(actual, expected, void 0, true), "not match with #{this}", "should not match with #{this}", true);
+        this.assert(equals(actual, expected, void 0, true), "not match with #{act}", "should not match with #{act}", actual, expected);
       } else {
         _super.apply(this, args);
       }
@@ -3425,7 +3425,7 @@ const JestChaiExpect = (chai, utils) => {
       const expected = args[0];
       const actual = utils.flag(this, "object");
       if (hasAsymmetric(expected)) {
-        this.assert(equals(actual, expected), "not match with #{this}", "should not match with #{this}", true);
+        this.assert(equals(actual, expected), "not match with #{exp}", "should not match with #{exp}", actual, expected);
       } else {
         _super.apply(this, args);
       }
@@ -3438,7 +3438,7 @@ const JestChaiExpect = (chai, utils) => {
     return this.chaiEqual(expected);
   });
   def("toBe", function(expected) {
-    return this.chaiEqual(expected);
+    return this.equal(expected);
   });
   def("toMatchObject", function(expected) {
     return this.containSubset(expected);
@@ -3535,7 +3535,7 @@ const JestChaiExpect = (chai, utils) => {
   def(["toHaveBeenCalledWith", "toBeCalledWith"], function(...args) {
     const spy = getSpy(this);
     const pass = spy.calls.some((callArg) => equals(callArg, args));
-    return this.assert(pass, "expected spy to be called with arguments: #{exp}", "expected spy to not be called with arguments: #{exp}", args);
+    return this.assert(pass, "expected spy to be called with arguments: #{exp}", "expected spy to not be called with arguments: #{exp}", args, spy.calls);
   });
   const ordinalOf = (i) => {
     const j = i % 10;
@@ -3630,7 +3630,7 @@ class StringContaining extends AsymmetricMatcher {
 }
 class Anything extends AsymmetricMatcher {
   asymmetricMatch(other) {
-    return other !== void 0 && other !== null;
+    return other != null;
   }
   toString() {
     return "Anything";
@@ -3639,11 +3639,127 @@ class Anything extends AsymmetricMatcher {
     return "Anything";
   }
 }
+class ObjectContaining extends AsymmetricMatcher {
+  constructor(sample, inverse = false) {
+    super(sample, inverse);
+  }
+  getPrototype(obj) {
+    if (Object.getPrototypeOf)
+      return Object.getPrototypeOf(obj);
+    if (obj.constructor.prototype === obj)
+      return null;
+    return obj.constructor.prototype;
+  }
+  hasProperty(obj, property) {
+    if (!obj)
+      return false;
+    if (Object.prototype.hasOwnProperty.call(obj, property))
+      return true;
+    return this.hasProperty(this.getPrototype(obj), property);
+  }
+  asymmetricMatch(other) {
+    if (typeof this.sample !== "object") {
+      throw new TypeError(`You must provide an object to ${this.toString()}, not '${typeof this.sample}'.`);
+    }
+    let result = true;
+    for (const property in this.sample) {
+      if (!this.hasProperty(other, property) || !equals(this.sample[property], other[property])) {
+        result = false;
+        break;
+      }
+    }
+    return this.inverse ? !result : result;
+  }
+  toString() {
+    return `Object${this.inverse ? "Not" : ""}Containing`;
+  }
+  getExpectedType() {
+    return "object";
+  }
+}
+class ArrayContaining extends AsymmetricMatcher {
+  constructor(sample, inverse = false) {
+    super(sample, inverse);
+  }
+  asymmetricMatch(other) {
+    if (!Array.isArray(this.sample)) {
+      throw new TypeError(`You must provide an array to ${this.toString()}, not '${typeof this.sample}'.`);
+    }
+    const result = this.sample.length === 0 || Array.isArray(other) && this.sample.every((item) => other.some((another) => equals(item, another)));
+    return this.inverse ? !result : result;
+  }
+  toString() {
+    return `Array${this.inverse ? "Not" : ""}Containing`;
+  }
+  getExpectedType() {
+    return "array";
+  }
+}
+class Any extends AsymmetricMatcher {
+  constructor(sample) {
+    if (typeof sample === "undefined") {
+      throw new TypeError("any() expects to be passed a constructor function. Please pass one or use anything() to match any object.");
+    }
+    super(sample);
+  }
+  fnNameFor(func) {
+    if (func.name)
+      return func.name;
+    const functionToString = Function.prototype.toString;
+    const matches = functionToString.call(func).match(/^(?:async)?\s*function\s*\*?\s*([\w$]+)\s*\(/);
+    return matches ? matches[1] : "<anonymous>";
+  }
+  asymmetricMatch(other) {
+    if (this.sample === String)
+      return typeof other == "string" || other instanceof String;
+    if (this.sample === Number)
+      return typeof other == "number" || other instanceof Number;
+    if (this.sample === Function)
+      return typeof other == "function" || other instanceof Function;
+    if (this.sample === Boolean)
+      return typeof other == "boolean" || other instanceof Boolean;
+    if (this.sample === BigInt)
+      return typeof other == "bigint" || other instanceof BigInt;
+    if (this.sample === Symbol)
+      return typeof other == "symbol" || other instanceof Symbol;
+    if (this.sample === Object)
+      return typeof other == "object";
+    return other instanceof this.sample;
+  }
+  toString() {
+    return "Any";
+  }
+  getExpectedType() {
+    if (this.sample === String)
+      return "string";
+    if (this.sample === Number)
+      return "number";
+    if (this.sample === Function)
+      return "function";
+    if (this.sample === Object)
+      return "object";
+    if (this.sample === Boolean)
+      return "boolean";
+    return this.fnNameFor(this.sample);
+  }
+  toAsymmetricMatcher() {
+    return `Any<${this.fnNameFor(this.sample)}>`;
+  }
+}
 const JestAsymmetricMatchers = (chai, utils) => {
   utils.addMethod(chai.expect, "stringContaining", (expected) => new StringContaining(expected));
   utils.addMethod(chai.expect, "anything", () => {
     return new Anything();
   });
+  utils.addMethod(chai.expect, "objectContaining", (expected) => {
+    return new ObjectContaining(expected);
+  });
+  utils.addMethod(chai.expect, "any", (expected) => {
+    return new Any(expected);
+  });
+  utils.addMethod(chai.expect, "arrayContaining", (expected) => {
+    return new ArrayContaining(expected);
+  });
 };
 
 let installed = false;
@@ -3666,7 +3782,7 @@ async function setupGlobalEnv(config) {
   setupConsoleLogSpy();
   await setupChai();
   if (config.global)
-    (await import('./global-c40aeb86.js')).registerApiGlobally();
+    (await import('./global-473089f7.js')).registerApiGlobally();
 }
 function setupConsoleLogSpy() {
   const stdout = new Writable({
@@ -3726,6 +3842,8 @@ function serializeError(val) {
     return "Promise";
   if (typeof Element !== "undefined" && val instanceof Element)
     return val.tagName;
+  if (typeof val.asymmetricMatch === "function")
+    return `${val.toString()} ${format$1(val.sample)}`;
   Object.keys(val).forEach((key) => {
     val[key] = serializeError(val[key]);
   });
@@ -3884,10 +4002,17 @@ async function startTests(paths, config) {
 }
 
 async function run(files, config) {
+  var _a;
   await setupGlobalEnv(config);
-  await withEnv(config.environment, async () => {
-    await startTests(files, config);
-  });
+  for (const file of files) {
+    const code = await promises.readFile(file, "utf-8");
+    const env = ((_a = code.match(/@(?:vitest|jest)-environment\s+?([\w-]+)\b/)) == null ? void 0 : _a[1]) || config.environment || "node";
+    if (!["node", "jsdom", "happy-dom"].includes(env))
+      throw new Error(`Unsupported environment: ${env}`);
+    await withEnv(env, async () => {
+      await startTests([file], config);
+    });
+  }
 }
 
 export { run };

package/dist/{error-abd1f726.js → error-81292c96.js}

@@ -1,6 +1,7 @@
 import { existsSync, promises } from 'fs';
 import { relative } from 'path';
-import { n as notNullish, c } from './utils-5d0cec8a.js';
+import { format } from 'util';
+import { d as notNullish, c } from './utils-576876dc.js';
 import { SourceMapConsumer } from 'source-map';
 
 function Diff() {}
@@ -1338,7 +1339,7 @@ function generateCodeFrame(source, indent = 0, start = 0, end, range = 2) {
   return res.join("\n");
 }
 function stringify(obj) {
-  return String(obj);
+  return format(obj);
 }
 const stackFnCallRE = /at (.*) \((.+):(\d+):(\d+)\)$/;
 const stackBarePathRE = /at ?(.*) (.+):(\d+):(\d+)$/;
@@ -1373,35 +1374,34 @@ function unifiedDiff(actual, expected) {
       if (expectedLinesCount >= diffLimit)
         return;
       expectedLinesCount++;
+      line = line[0] + " " + line.slice(1);
       const isLastLine = expectedLinesCount === diffLimit;
-      return indent + c.green(`${formatLine(line)} ${isLastLine ? renderTruncateMessage(indent) : ""}`);
+      return indent + c.red(`${formatLine(line)} ${isLastLine ? renderTruncateMessage(indent) : ""}`);
     }
     if (line[0] === "-") {
       if (actualLinesCount >= diffLimit)
         return;
       actualLinesCount++;
+      line = line[0] + " " + line.slice(1);
       const isLastLine = actualLinesCount === diffLimit;
-      return indent + c.red(`${formatLine(line)} ${isLastLine ? renderTruncateMessage(indent) : ""}`);
+      return indent + c.green(`${formatLine(line)} ${isLastLine ? renderTruncateMessage(indent) : ""}`);
     }
     if (line.match(/@@/))
       return "--";
     if (line.match(/\\ No newline/))
       return null;
-    return indent + line;
+    return indent + " " + line;
   }
   const msg = createPatch("string", actual, expected);
   const lines = msg.split("\n").splice(5);
   return `
-${indent}${c.red("- actual")}
-${indent}${c.green("+ expected")}
+${indent}${c.green("- expected")}
+${indent}${c.red("+ actual")}
 
 ${lines.map(cleanUp).filter(notBlank).join("\n")}`;
 }
 function formatLine(line) {
-  const lineLimitLength = 50;
-  if (line.length > lineLimitLength)
-    return `${line.slice(0, lineLimitLength)} ${c.dim("[...truncated]")}`;
-  return line;
+  return cliTruncate(line, (process.stdout.columns || 40) - 1);
 }
 function renderTruncateMessage(indent) {
   return `

package/dist/{global-c40aeb86.js → global-473089f7.js}

@@ -1,5 +1,5 @@
 import { g as globalApis } from './constants-9cfa4d7b.js';
-import { i as index } from './index-708135df.js';
+import { i as index } from './index-368448f4.js';
 import 'path';
 import 'url';
 import './suite-b8c6cb53.js';

package/dist/{index-708135df.js → index-368448f4.js}

@@ -1,7 +1,7 @@
 import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, s as suite, t as test, d as describe, i as it } from './suite-b8c6cb53.js';
 import chai, { util, assert, should, expect } from 'chai';
 import * as tinyspy from 'tinyspy';
-import { spy, spyOn as spyOn$1 } 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()));
@@ -136,7 +136,8 @@ class FakeTimers {
     const spyFactory = (spyType, resultBuilder) => {
       return (cb, ms = 0) => {
         const id = ++this._spyid;
-        const nestedMs = ms + (this._nestedTime[this._scopeId] ?? 0);
+        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);
@@ -306,6 +307,24 @@ class VitestUtils {
   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;
@@ -324,10 +343,10 @@ var index = /*#__PURE__*/Object.freeze({
   should: should,
   expect: expect,
   chai: chai,
-  spy: spy,
-  spyOn: spyOn$1,
+  spyOn: spyOn,
+  fn: fn,
   vitest: vitest,
   vi: vi
 });
 
-export { afterAll as a, beforeAll as b, beforeEach as c, afterEach as d, vi as e, index as i, vitest as v };
+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 };