vitest 0.0.78 → 0.0.82

package/dist/{constants-2435fa16.js → constants-adef7ffb.js}

@@ -2,8 +2,8 @@ import { resolve } from 'path';
 import { fileURLToPath } from 'url';
 
 const distDir = resolve(fileURLToPath(import.meta.url), "../../dist");
-const defaultIncludes = ["**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"];
-const defaultExcludes = ["**/node_modules/**", "**/dist/**"];
+const defaultInclude = ["**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"];
+const defaultExclude = ["**/node_modules/**", "**/dist/**"];
 const defaultPort = 51204;
 const API_PATH = "/__vitest_api__";
 const configFiles = [
@@ -22,14 +22,13 @@ const globalApis = [
   "chai",
   "expect",
   "assert",
-  "sinon",
   "spy",
-  "mock",
-  "stub",
+  "spyOn",
+  "vitest",
   "beforeAll",
   "afterAll",
   "beforeEach",
   "afterEach"
 ];
 
-export { API_PATH as A, defaultExcludes as a, defaultPort as b, configFiles as c, defaultIncludes as d, distDir as e, globalApis as g };
+export { API_PATH as A, defaultExclude as a, defaultPort as b, distDir as c, defaultInclude as d, configFiles as e, globalApis as g };

package/dist/entry.js

@@ -2,12 +2,12 @@ import { Console } from 'console';
 import { Writable } from 'stream';
 import { importModule } from 'local-pkg';
 import chai, { expect, util } from 'chai';
-import SinonChai from 'sinon-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, t as toArray, i as interpretOnlyMode, p as partitionSuiteChildren, c as hasTests, h as hasFailed } from './utils-9dcc4050.js';
 import fs from 'fs';
-import { d as c$1, m as generateDiff } from './error-c9295525.js';
+import { c as c$1, m as generateDiff } from './error-dd23da12.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-95be5909.js';
 import { n as nanoid } from './index-9e71c815.js';
@@ -296,15 +296,6 @@ const environments = {
   "happy-dom": happy
 };
 
-const rpc = async (method, ...args) => {
-  var _a;
-  return (_a = process.__vitest_worker__) == null ? void 0 : _a.rpc(method, ...args);
-};
-const send = async (method, ...args) => {
-  var _a;
-  return (_a = process.__vitest_worker__) == null ? void 0 : _a.send(method, ...args);
-};
-
 var naturalCompare$2 = {exports: {}};
 
 /*
@@ -752,7 +743,7 @@ const asymmetricMatcher =
     : 0x1357a5;
 const SPACE$2 = ' ';
 
-const serialize$7 = (val, config, indentation, depth, refs, printer) => {
+const serialize$8 = (val, config, indentation, depth, refs, printer) => {
   const stringedValue = val.toString();
 
   if (
@@ -828,13 +819,13 @@ const serialize$7 = (val, config, indentation, depth, refs, printer) => {
   return val.toAsymmetricMatcher();
 };
 
-AsymmetricMatcher$2.serialize = serialize$7;
+AsymmetricMatcher$2.serialize = serialize$8;
 
 const test$6 = val => val && val.$$typeof === asymmetricMatcher;
 
 AsymmetricMatcher$2.test = test$6;
 const plugin$6 = {
-  serialize: serialize$7,
+  serialize: serialize$8,
   test: test$6
 };
 var _default$7 = plugin$6;
@@ -935,12 +926,12 @@ const test$5 = val =>
 
 ConvertAnsi.test = test$5;
 
-const serialize$6 = (val, config, indentation, depth, refs, printer) =>
+const serialize$7 = (val, config, indentation, depth, refs, printer) =>
   printer(toHumanReadableAnsi(val), config, indentation, depth, refs);
 
-ConvertAnsi.serialize = serialize$6;
+ConvertAnsi.serialize = serialize$7;
 const plugin$5 = {
-  serialize: serialize$6,
+  serialize: serialize$7,
   test: test$5
 };
 var _default$6 = plugin$5;
@@ -981,7 +972,7 @@ DOMCollection$2.test = test$4;
 const isNamedNodeMap = collection =>
   collection.constructor.name === 'NamedNodeMap';
 
-const serialize$5 = (collection, config, indentation, depth, refs, printer) => {
+const serialize$6 = (collection, config, indentation, depth, refs, printer) => {
   const name = collection.constructor.name;
 
   if (++depth > config.maxDepth) {
@@ -1019,9 +1010,9 @@ const serialize$5 = (collection, config, indentation, depth, refs, printer) => {
   );
 };
 
-DOMCollection$2.serialize = serialize$5;
+DOMCollection$2.serialize = serialize$6;
 const plugin$4 = {
-  serialize: serialize$5,
+  serialize: serialize$6,
   test: test$4
 };
 var _default$5 = plugin$4;
@@ -1269,7 +1260,7 @@ function nodeIsFragment(node) {
   return node.nodeType === FRAGMENT_NODE;
 }
 
-const serialize$4 = (node, config, indentation, depth, refs, printer) => {
+const serialize$5 = (node, config, indentation, depth, refs, printer) => {
   if (nodeIsText(node)) {
     return (0, _markup$2.printText)(node.data, config);
   }
@@ -1319,9 +1310,9 @@ const serialize$4 = (node, config, indentation, depth, refs, printer) => {
   );
 };
 
-DOMElement$2.serialize = serialize$4;
+DOMElement$2.serialize = serialize$5;
 const plugin$3 = {
-  serialize: serialize$4,
+  serialize: serialize$5,
   test: test$3
 };
 var _default$4 = plugin$3;
@@ -1504,7 +1495,7 @@ const printImmutableValues = (
       ) +
       ']';
 
-const serialize$3 = (val, config, indentation, depth, refs, printer) => {
+const serialize$4 = (val, config, indentation, depth, refs, printer) => {
   if (val[IS_MAP_SENTINEL]) {
     return printImmutableEntries(
       val,
@@ -1561,7 +1552,7 @@ const serialize$3 = (val, config, indentation, depth, refs, printer) => {
 }; // Explicitly comparing sentinel properties to true avoids false positive
 // when mock identity-obj-proxy returns the key as the value for any key.
 
-Immutable$2.serialize = serialize$3;
+Immutable$2.serialize = serialize$4;
 
 const test$2 = val =>
   val &&
@@ -1569,7 +1560,7 @@ const test$2 = val =>
 
 Immutable$2.test = test$2;
 const plugin$2 = {
-  serialize: serialize$3,
+  serialize: serialize$4,
   test: test$2
 };
 var _default$3 = plugin$2;
@@ -1952,7 +1943,7 @@ const getPropKeys$1 = element => {
     .sort();
 };
 
-const serialize$2 = (element, config, indentation, depth, refs, printer) =>
+const serialize$3 = (element, config, indentation, depth, refs, printer) =>
   ++depth > config.maxDepth
     ? (0, _markup$1.printElementAsLeaf)(getType(element), config)
     : (0, _markup$1.printElement)(
@@ -1978,13 +1969,13 @@ const serialize$2 = (element, config, indentation, depth, refs, printer) =>
         indentation
       );
 
-ReactElement$2.serialize = serialize$2;
+ReactElement$2.serialize = serialize$3;
 
 const test$1 = val => val != null && ReactIs.isElement(val);
 
 ReactElement$2.test = test$1;
 const plugin$1 = {
-  serialize: serialize$2,
+  serialize: serialize$3,
   test: test$1
 };
 var _default$2 = plugin$1;
@@ -2028,7 +2019,7 @@ const getPropKeys = object => {
     : [];
 };
 
-const serialize$1 = (object, config, indentation, depth, refs, printer) =>
+const serialize$2 = (object, config, indentation, depth, refs, printer) =>
   ++depth > config.maxDepth
     ? (0, _markup.printElementAsLeaf)(object.type, config)
     : (0, _markup.printElement)(
@@ -2058,13 +2049,13 @@ const serialize$1 = (object, config, indentation, depth, refs, printer) =>
         indentation
       );
 
-ReactTestComponent$2.serialize = serialize$1;
+ReactTestComponent$2.serialize = serialize$2;
 
 const test = val => val && val.$$typeof === testSymbol;
 
 ReactTestComponent$2.test = test;
 const plugin = {
-  serialize: serialize$1,
+  serialize: serialize$2,
   test
 };
 var _default$1 = plugin;
@@ -2730,7 +2721,7 @@ ${string}
 const removeExtraLineBreaks = (string) => string.length > 2 && string.startsWith("\n") && string.endsWith("\n") ? string.slice(1, -1) : string;
 const escapeRegex = true;
 const printFunctionName = false;
-function serialize(val, indent = 2, formatOverrides = {}) {
+function serialize$1(val, indent = 2, formatOverrides = {}) {
   return normalizeNewlines(format_1(val, __spreadValues$1({
     escapeRegex,
     indent,
@@ -2844,7 +2835,7 @@ class SnapshotState {
       key = testNameToKey(testName, count);
     if (!(isInline && this._snapshotData[key] !== void 0))
       this._uncheckedKeys.delete(key);
-    const receivedSerialized = addExtraLineBreaks(serialize(received, void 0, this._snapshotFormat));
+    const receivedSerialized = addExtraLineBreaks(serialize$1(received, void 0, this._snapshotFormat));
     const expected = isInline ? inlineSnapshot : this._snapshotData[key];
     const pass = (expected == null ? void 0 : expected.trim()) === (receivedSerialized == null ? void 0 : receivedSerialized.trim());
     const hasSnapshot = expected !== void 0;
@@ -3509,30 +3500,29 @@ function JestChaiExpect() {
       return this.closeTo(number, numDigits);
     });
     function isSpy(putativeSpy) {
-      return typeof putativeSpy === "function" && typeof putativeSpy.getCall === "function" && typeof putativeSpy.calledWithExactly === "function";
-    }
-    function isCall(putativeCall) {
-      return putativeCall && isSpy(putativeCall.proxy);
+      return typeof putativeSpy === "function" && "__isSpy" in putativeSpy && putativeSpy.__isSpy;
     }
     const assertIsMock = (assertion) => {
-      if (!isSpy(assertion._obj) && !isCall(assertion._obj))
+      if (!isSpy(assertion._obj))
         throw new TypeError(`${utils.inspect(assertion._obj)} is not a spy or a call to a spy!`);
     };
+    const getSpy = (assertion) => {
+      assertIsMock(assertion);
+      return assertion._obj;
+    };
     def(["toHaveBeenCalledTimes", "toBeCalledTimes"], function(number) {
-      assertIsMock(this);
-      return this.callCount(number);
+      return this.assert(getSpy(this).callCount === number, "expected spy to be called #{exp} times", "expected spy to not be called #{exp} times", number);
     });
     def("toHaveBeenCalledOnce", function() {
-      assertIsMock(this);
-      return this.callCount(1);
+      return this.assert(getSpy(this).callCount === 1, "expected spy to be called once", "expected spy to not be called once", 1);
     });
     def(["toHaveBeenCalled", "toBeCalled"], function() {
-      assertIsMock(this);
-      return this.called;
+      return this.assert(getSpy(this).called, "expected spy to be called at least once", "expected spy to not be called at all", true);
     });
     def(["toHaveBeenCalledWith", "toBeCalledWith"], function(...args) {
-      assertIsMock(this);
-      return this.calledWith(...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);
     });
     const ordinalOf = (i) => {
       const j = i % 10;
@@ -3546,16 +3536,14 @@ function JestChaiExpect() {
       return `${i}th`;
     };
     def(["toHaveBeenNthCalledWith", "nthCalledWith"], function(times, ...args) {
-      assertIsMock(this);
-      const spy = utils.flag(this, "object");
-      const nthCall = spy.getCall(times - 1);
-      this.assert(nthCall.calledWith(...args), `expected ${ordinalOf(times)} spy call to have been called with #{exp}`, `expected ${ordinalOf(times)} spy call not to have been called with #{exp}`, args, nthCall.args);
+      const spy = getSpy(this);
+      const nthCall = spy.calls[times - 1];
+      this.assert(equals(nthCall, args), `expected ${ordinalOf(times)} spy call to have been called with #{exp}`, `expected ${ordinalOf(times)} spy call to not have been called with #{exp}`, args, nthCall);
     });
     def(["toHaveBeenLastCalledWith", "lastCalledWith"], function(...args) {
-      assertIsMock(this);
-      const spy = utils.flag(this, "object");
-      const lastCall = spy.getCall(spy.returnValues.length - 1);
-      this.assert(lastCall.calledWith(...args), "expected last spy call to have been called with #{exp}", "expected last spy call not to have been called with #{exp}", args, lastCall.args);
+      const spy = getSpy(this);
+      const lastCall = spy.calls.at(-1);
+      this.assert(equals(lastCall, args), "expected last spy call to have been called with #{exp}", "expected last spy call to not have been called with #{exp}", args, lastCall);
     });
     def(["toThrow", "toThrowError"], function(expected) {
       const negate = utils.flag(this, "negate");
@@ -3565,37 +3553,35 @@ function JestChaiExpect() {
         this.to.throw(expected);
     });
     def(["toHaveReturned", "toReturn"], function() {
-      assertIsMock(this);
-      const spy = utils.flag(this, "object");
-      const calledAndNotThrew = spy.called && !spy.alwaysThrew();
-      this.assert(calledAndNotThrew, "expected spy to be successfully called at least once", "expected spy not to be successfully called", calledAndNotThrew, !calledAndNotThrew);
+      const spy = getSpy(this);
+      const calledAndNotThrew = spy.called && !spy.results.some(([type]) => type === "error");
+      this.assert(calledAndNotThrew, "expected spy to be successfully called at least once", "expected spy to not be successfully called", calledAndNotThrew, !calledAndNotThrew);
     });
     def(["toHaveReturnedTimes", "toReturnTimes"], function(times) {
-      assertIsMock(this);
-      const spy = utils.flag(this, "object");
-      const successfullReturns = spy.getCalls().reduce((success, call) => call.threw() ? success : ++success, 0);
-      this.assert(successfullReturns === times, `expected spy to be successfully called ${times} times`, `expected spy not to be successfully called ${times} times`, `expected number of returns: ${times}`, `recieved number of returns: ${successfullReturns}`);
+      const spy = getSpy(this);
+      const successfullReturns = spy.results.reduce((success, [type]) => type === "error" ? success : ++success, 0);
+      this.assert(successfullReturns === times, `expected spy to be successfully called ${times} times`, `expected spy to not be successfully called ${times} times`, `expected number of returns: ${times}`, `received number of returns: ${successfullReturns}`);
     });
     def(["toHaveReturnedWith", "toReturnWith"], function(value) {
-      assertIsMock(this);
-      return this.returned(value);
+      const spy = getSpy(this);
+      const pass = spy.results.some(([type, result]) => type === "ok" && equals(value, result));
+      this.assert(pass, "expected spy to be successfully called with #{exp}", "expected spy to not be successfully called with #{exp}", value);
     });
     def(["toHaveLastReturnedWith", "lastReturnedWith"], function(value) {
-      assertIsMock(this);
-      const spy = utils.flag(this, "object");
-      const lastReturn = spy.lastCall.returned(value);
-      this.assert(lastReturn, "expected last spy call to return #{exp}", "expected last spy call not to return #{exp}", value, spy.lastCall.returnValue);
+      const spy = getSpy(this);
+      const lastResult = spy.returns.at(-1);
+      const pass = equals(lastResult, value);
+      this.assert(pass, "expected last spy call to return #{exp}", "expected last spy call to not return #{exp}", value, lastResult);
     });
     def(["toHaveNthReturnedWith", "nthReturnedWith"], function(nthCall, value) {
-      assertIsMock(this);
-      const spy = utils.flag(this, "object");
+      const spy = getSpy(this);
       const isNot = utils.flag(this, "negate");
-      const call = spy.getCall(nthCall - 1);
+      const [callType, callResult] = spy.results[nthCall - 1];
       const ordinalCall = `${ordinalOf(nthCall)} call`;
-      if (!isNot && call.threw())
+      if (!isNot && callType === "error")
         chai.assert.fail(`expected ${ordinalCall} to return #{exp}, but instead it threw an error`);
-      const nthCallReturn = call.returned(value);
-      this.assert(nthCallReturn, `expected ${ordinalCall} spy call to return #{exp}`, `expected ${ordinalCall} spy call not to return #{exp}`, value, call.returnValue);
+      const nthCallReturn = equals(callResult, value);
+      this.assert(nthCallReturn, `expected ${ordinalCall} spy call to return #{exp}`, `expected ${ordinalCall} spy call to not return #{exp}`, value, callResult);
     });
   };
 }
@@ -3604,7 +3590,6 @@ let installed = false;
 async function setupChai() {
   if (installed)
     return;
-  chai.use(SinonChai);
   chai.use(JestExtend());
   chai.use(JestChaiExpect());
   chai.use(Subset);
@@ -3620,7 +3605,7 @@ async function setupGlobalEnv(config) {
   setupConsoleLogSpy();
   await setupChai();
   if (config.global)
-    (await import('./global-38c2f902.js')).registerApiGlobally();
+    (await import('./global-cae0ce06.js')).registerApiGlobally();
 }
 function setupConsoleLogSpy() {
   const stdout = new Writable({
@@ -3669,6 +3654,23 @@ async function runSetupFiles(config) {
   }));
 }
 
+function serialize(err) {
+  if (typeof err !== "object")
+    return err;
+  Object.keys(err).forEach((key) => {
+    const val = err[key];
+    if (typeof val === "function")
+      err[key] = `Function<${val.name}>`;
+    if (typeof val !== "object")
+      return;
+    if ("then" in val)
+      err[key] = "Promise";
+    if (typeof Element !== "undefined" && val instanceof Element)
+      err[key] = val.tagName;
+    serialize(err[key]);
+  });
+  return err;
+}
 function processError(err) {
   if (!err)
     return err;
@@ -3676,7 +3678,7 @@ function processError(err) {
     err.stackStr = String(err.stack);
   if (err.name)
     err.nameStr = String(err.name);
-  return err;
+  return serialize(err);
 }
 
 async function collectTests(paths, config) {
@@ -3696,9 +3698,12 @@ async function collectTests(paths, config) {
     try {
       await runSetupFiles(config);
       await import(filepath);
-      for (const c of [defaultSuite, ...context.tasks]) {
+      const defaultTasks = await defaultSuite.collect(file);
+      for (const c of [...defaultTasks.tasks, ...context.tasks]) {
         if (c.type === "test") {
           file.tasks.push(c);
+        } else if (c.type === "suite") {
+          file.tasks.push(c);
         } else {
           const suite = await c.collect(file);
           if (suite.name || suite.tasks.length)

package/dist/{error-c9295525.js → error-dd23da12.js}

@@ -1303,7 +1303,7 @@ async function printStack(ctx, stack, highlight, onStack) {
     const color = frame === highlight ? c.yellow : c.gray;
     const path = relative(ctx.config.root, frame.file);
     ctx.console.log(color(` ${c.dim(F_POINTER)} ${[frame.method, c.dim(`${path}:${pos.line}:${pos.column}`)].filter(Boolean).join(" ")}`));
-    onStack == null ? void 0 : onStack(frame, pos);
+    await (onStack == null ? void 0 : onStack(frame, pos));
     if (frame.file in ctx.state.filesMap)
       break;
   }
@@ -1428,4 +1428,4 @@ function notBlank(line) {
   return typeof line !== "undefined" && line !== null;
 }
 
-export { F_POINTER as F, ansiStyles as a, stripAnsi as b, sliceAnsi as c, c as d, F_DOWN as e, F_LONG_DASH as f, F_DOWN_RIGHT as g, F_DOT as h, F_CHECK as i, F_CROSS as j, cliTruncate as k, F_RIGHT as l, generateDiff as m, printError as p, stringWidth as s };
+export { F_POINTER as F, ansiStyles as a, stripAnsi as b, c, sliceAnsi as d, F_DOWN as e, F_LONG_DASH as f, F_DOWN_RIGHT as g, F_DOT as h, F_CHECK as i, F_CROSS as j, cliTruncate as k, F_RIGHT as l, generateDiff as m, printError as p, stringWidth as s };

package/dist/{global-38c2f902.js → global-cae0ce06.js}

@@ -1,11 +1,11 @@
-import { g as globalApis } from './constants-2435fa16.js';
-import { i as index } from './index-6feda5ef.js';
+import { g as globalApis } from './constants-adef7ffb.js';
+import { i as index } from './index-16a06164.js';
 import 'path';
 import 'url';
 import './suite-95be5909.js';
 import './index-9e71c815.js';
 import 'chai';
-import 'sinon';
+import 'tinyspy';
 
 function registerApiGlobally() {
   globalApis.forEach((api) => {

package/dist/{index-6feda5ef.js → index-16a06164.js}

@@ -1,14 +1,16 @@
 import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, s as suite, t as test, d as describe, i as it } from './suite-95be5909.js';
 import chai, { assert, should, expect } from 'chai';
-import sinon from 'sinon';
+import { spyOn, spy } 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()));
 
-const { mock, spy, stub } = sinon;
-sinon.fn = sinon.spy;
+const vitest = {
+  spyOn,
+  fn: spy
+};
 
 var index = /*#__PURE__*/Object.freeze({
   __proto__: null,
@@ -24,10 +26,9 @@ var index = /*#__PURE__*/Object.freeze({
   should: should,
   expect: expect,
   chai: chai,
-  sinon: sinon,
-  mock: mock,
   spy: spy,
-  stub: stub
+  spyOn: spyOn,
+  vitest: vitest
 });
 
-export { afterAll as a, beforeAll as b, beforeEach as c, afterEach as d, stub as e, index as i, mock as m, spy as s };
+export { afterAll as a, beforeAll as b, beforeEach as c, afterEach as d, index as i, vitest as v };