vitest 0.0.103 → 0.0.104

package/dist/index.d.ts

@@ -150,6 +150,12 @@ declare class Any extends AsymmetricMatcher<any> {
     getExpectedType(): string;
     toAsymmetricMatcher(): string;
 }
+declare class StringMatching extends AsymmetricMatcher<RegExp> {
+    constructor(sample: string | RegExp, inverse?: boolean);
+    asymmetricMatch(other: string): boolean;
+    toString(): string;
+    getExpectedType(): string;
+}
 
 declare type Awaitable<T> = T | PromiseLike<T>;
 declare type Nullable<T> = T | null | undefined;
@@ -426,6 +432,21 @@ interface InlineConfig {
      * @default false
      */
     api?: boolean | number;
+    /**
+     * Will call `.mockClear()` on all spies before each test
+     * @default false
+     */
+    clearMocks?: boolean;
+    /**
+     * Will call `.mockReset()` on all spies before each test
+     * @default false
+     */
+    mockReset?: boolean;
+    /**
+     * Will call `.mockRestore()` on all spies before each test
+     * @default false
+     */
+    restoreMocks?: boolean;
 }
 interface UserConfig extends InlineConfig {
     /**
@@ -494,6 +515,7 @@ declare global {
                 rpc: RpcCall;
                 send: RpcSend;
                 current?: Test;
+                filepath?: string;
                 moduleCache: Map<string, ModuleCache>;
             };
         }
@@ -545,6 +567,37 @@ interface JestMockCompat<TArgs extends any[] = any[], TReturns = any> {
 interface JestMockCompatFn<TArgs extends any[] = any, TReturns = any> extends JestMockCompat<TArgs, TReturns> {
     (...args: TArgs): TReturns;
 }
+declare type MockableFunction = (...args: Array<any>) => any;
+declare type MethodKeysOf<T> = {
+    [K in keyof T]: T[K] extends MockableFunction ? K : never;
+}[keyof T];
+declare type PropertyKeysOf<T> = {
+    [K in keyof T]: T[K] extends MockableFunction ? never : K;
+}[keyof T];
+declare type ArgumentsOf<T> = T extends (...args: infer A) => any ? A : never;
+declare type ConstructorArgumentsOf<T> = T extends new (...args: infer A) => any ? A : never;
+declare type MaybeMockedConstructor<T> = T extends new (...args: Array<any>) => infer R ? JestMockCompatFn<ConstructorArgumentsOf<T>, R> : T;
+declare type MockedFunction<T extends MockableFunction> = MockWithArgs<T> & {
+    [K in keyof T]: T[K];
+};
+declare type MockedFunctionDeep<T extends MockableFunction> = MockWithArgs<T> & MockedObjectDeep<T>;
+declare type MockedObject<T> = MaybeMockedConstructor<T> & {
+    [K in MethodKeysOf<T>]: T[K] extends MockableFunction ? MockedFunction<T[K]> : T[K];
+} & {
+    [K in PropertyKeysOf<T>]: T[K];
+};
+declare type MockedObjectDeep<T> = MaybeMockedConstructor<T> & {
+    [K in MethodKeysOf<T>]: T[K] extends MockableFunction ? MockedFunctionDeep<T[K]> : T[K];
+} & {
+    [K in PropertyKeysOf<T>]: MaybeMockedDeep<T[K]>;
+};
+declare type MaybeMockedDeep<T> = T extends MockableFunction ? MockedFunctionDeep<T> : T extends object ? MockedObjectDeep<T> : T;
+declare type MaybeMocked<T> = T extends MockableFunction ? MockedFunction<T> : T extends object ? MockedObject<T> : T;
+interface MockWithArgs<T extends MockableFunction> extends JestMockCompatFn<ArgumentsOf<T>, ReturnType<T>> {
+    new (...args: ConstructorArgumentsOf<T>): T;
+    (...args: ArgumentsOf<T>): ReturnType<T>;
+}
+declare const spies: Set<JestMockCompat<any[], any>>;
 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 Awaited<T> = T extends Promise<infer R> ? R : never;
 declare function fn<TArgs extends any[] = any[], R = any>(): JestMockCompatFn<TArgs, R>;
@@ -559,17 +612,19 @@ declare class VitestUtils {
     runAllTimers(): void | Promise<void>;
     advanceTimersByTime(ms: number): void | Promise<void>;
     advanceTimersToNextTimer(): void | Promise<void>;
-    runAllTicks(): void | Promise<void>;
-    setSystemTime(time?: number | Date): void;
-    getRealSystemTime(): number;
     getTimerCount(): number;
     spyOn: typeof spyOn;
     fn: typeof fn;
-    mock: (path: string) => string;
+    mock(path: string): void;
+    unmock(path: string): void;
+    importActual<T>(path: string): Promise<T>;
+    importMock<T>(path: string): Promise<T>;
+    mocked<T>(item: T, deep?: false): MaybeMocked<T>;
+    mocked<T>(item: T, deep: true): MaybeMockedDeep<T>;
     isMockFunction(fn: any): any;
-    clearAllMocks(): void;
-    resetAllMocks(): void;
-    restoreAllMocks(): void;
+    clearAllMocks(): this;
+    resetAllMocks(): this;
+    restoreAllMocks(): this;
 }
 declare const vitest: VitestUtils;
 declare const vi: VitestUtils;
@@ -593,6 +648,7 @@ declare global {
             objectContaining(expected: any): ObjectContaining;
             any(constructor: unknown): Any;
             arrayContaining(expected: any): ArrayContaining;
+            stringMatching(expected: RegExp): StringMatching;
         }
         interface Assertion {
             chaiEqual(expected: any): void;
@@ -647,4 +703,4 @@ declare global {
     }
 }
 
-export { ArgumentsType, Arrayable, Awaitable, BuiltinEnvironment, ComputeMode, DoneCallback, Environment, EnvironmentReturn, File, HookListener, InlineConfig, JestMockCompat, JestMockCompatContext, JestMockCompatFn, ModuleCache, Nullable, Reporter, ResolvedConfig, RpcCall, RpcMap, RpcPayload, RpcSend, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, Suite, SuiteCollector, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestCollector, TestFactory, TestFunction, UncheckedSnapshot, UserConfig, UserConsoleLog, WorkerContext, afterAll, afterEach, beforeAll, beforeEach, describe, fn, it, spyOn, suite, test, vi, vitest };
+export { ArgumentsOf, ArgumentsType, Arrayable, Awaitable, BuiltinEnvironment, ComputeMode, ConstructorArgumentsOf, DoneCallback, Environment, EnvironmentReturn, File, HookListener, InlineConfig, JestMockCompat, JestMockCompatContext, JestMockCompatFn, MaybeMocked, MaybeMockedConstructor, MaybeMockedDeep, MethodKeysOf, MockWithArgs, MockableFunction, MockedFunction, MockedFunctionDeep, MockedObject, MockedObjectDeep, ModuleCache, Nullable, PropertyKeysOf, Reporter, ResolvedConfig, RpcCall, RpcMap, RpcPayload, RpcSend, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, Suite, SuiteCollector, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestCollector, TestFactory, TestFunction, UncheckedSnapshot, UserConfig, UserConsoleLog, WorkerContext, afterAll, afterEach, beforeAll, beforeEach, describe, fn, it, spies, spyOn, suite, test, vi, vitest };

package/dist/index.js

@@ -1,8 +1,8 @@
-export { d as describe, i as it, s as suite, t as test } from './suite-64b3e636.js';
-export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, f as fn, s as spyOn, e as vi, v as vitest } from './index-a190f5a1.js';
+export { d as describe, i as it, s as suite, t as test } from './suite-8d666d5a.js';
+export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach } from './index-145f6f09.js';
 export { assert, default as chai, expect, should } from 'chai';
+export { f as fn, s as spies, a as spyOn, b as vi, v as vitest } from './utils-49e5008c.js';
 import './index-9e71c815.js';
-import './utils-c8e62373.js';
 import 'tty';
 import 'local-pkg';
 import 'path';

package/dist/{middleware-05e03d95.js → middleware-0627688d.js}

@@ -1,9 +1,11 @@
-import { A as API_PATH } from './constants-a1417084.js';
+import { A as API_PATH } from './constants-c4dc2ff5.js';
 import 'url';
-import './utils-c8e62373.js';
+import './utils-49e5008c.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
+import 'chai';
+import 'tinyspy';
 
 /*! (c) 2020 Andrea Giammarchi */
 

package/dist/node.d.ts

@@ -218,6 +218,21 @@ interface InlineConfig {
      * @default false
      */
     api?: boolean | number;
+    /**
+     * Will call `.mockClear()` on all spies before each test
+     * @default false
+     */
+    clearMocks?: boolean;
+    /**
+     * Will call `.mockReset()` on all spies before each test
+     * @default false
+     */
+    mockReset?: boolean;
+    /**
+     * Will call `.mockRestore()` on all spies before each test
+     * @default false
+     */
+    restoreMocks?: boolean;
 }
 interface UserConfig extends InlineConfig {
     /**

package/dist/node.js

@@ -1,8 +1,10 @@
-export { c as createVitest } from './index-6f17b444.js';
-import './utils-c8e62373.js';
+export { c as createVitest } from './index-40564dba.js';
+import './utils-49e5008c.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
+import 'chai';
+import 'tinyspy';
 import 'vite';
 import 'process';
 import 'fs';
@@ -10,10 +12,10 @@ import 'os';
 import 'util';
 import 'stream';
 import 'events';
-import './constants-a1417084.js';
+import './constants-c4dc2ff5.js';
 import 'url';
 import 'perf_hooks';
-import './error-0e2f75a4.js';
+import './error-796962c6.js';
 import './index-825cb54c.js';
 import './_commonjsHelpers-bdec4bbd.js';
 import 'assert';

package/dist/{suite-64b3e636.js → suite-8d666d5a.js}

@@ -1,5 +1,5 @@
 import { n as nanoid } from './index-9e71c815.js';
-import { n as noop } from './utils-c8e62373.js';
+import { n as noop } from './utils-49e5008c.js';
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;

package/dist/{utils-c8e62373.js → utils-49e5008c.js}

@@ -1,6 +1,8 @@
 import require$$0 from 'tty';
 import { isPackageExists } from 'local-pkg';
 import path from 'path';
+import { util } from 'chai';
+import * as tinyspy from 'tinyspy';
 
 var picocolors = {exports: {}};
 
@@ -248,6 +250,330 @@ const index = {
   ..._path
 };
 
+const spies = /* @__PURE__ */ new Set();
+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();
+    implementation = () => void 0;
+    onceImplementations = [];
+    return stub;
+  };
+  stub.mockRestore = () => {
+    stub.mockReset();
+    implementation = void 0;
+    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.mockImplementationOnce(() => 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);
+  });
+  spies.add(stub);
+  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() {
+    this.assertMocked();
+    this.callQueueItem(0);
+  }
+  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();
+  }
+  callQueueItem(index) {
+    var _a, _b;
+    const task = this._tasksQueue[index];
+    if (!task)
+      return;
+    const { call, type } = task;
+    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++;
+  }
+  runQueue() {
+    let index = 0;
+    while (this._tasksQueue[index]) {
+      assertMaxLoop(this._queueCount);
+      const { call, nested } = this._tasksQueue[index];
+      if (this._advancedTime && call.nestedMs > this._advancedTime)
+        break;
+      if (this._isOnlyPending && nested) {
+        index++;
+        continue;
+      }
+      this.callQueueItem(index);
+    }
+  }
+  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._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();
+  }
+  getTimerCount() {
+    return this._timers.getTimerCount();
+  }
+  mock(path) {
+  }
+  unmock(path) {
+  }
+  async importActual(path) {
+    return {};
+  }
+  async importMock(path) {
+    return {};
+  }
+  mocked(item, _deep = false) {
+    return item;
+  }
+  isMockFunction(fn2) {
+    return typeof fn2 === "function" && "__isSpy" in fn2 && fn2.__isSpy;
+  }
+  clearAllMocks() {
+    __vitest__clearMocks__({ clearMocks: true });
+    spies.forEach((spy) => spy.mockClear());
+    return this;
+  }
+  resetAllMocks() {
+    __vitest__clearMocks__({ mockReset: true });
+    spies.forEach((spy) => spy.mockReset());
+    return this;
+  }
+  restoreAllMocks() {
+    __vitest__clearMocks__({ restoreMocks: true });
+    spies.forEach((spy) => spy.mockRestore());
+    return this;
+  }
+}
+const vitest = new VitestUtils();
+const vi = vitest;
+
 function toArray(array) {
   array = array || [];
   if (Array.isArray(array))
@@ -260,6 +586,9 @@ function notNullish(v) {
 function slash(str) {
   return str.replace(/\\/g, "/");
 }
+function mergeSlashes(str) {
+  return str.replace(/\/\//g, "/");
+}
 const noop = () => {
 };
 function partitionSuiteChildren(suite) {
@@ -342,5 +671,14 @@ async function ensurePackageInstalled(dependency, promptInstall = !process.env.C
   }
   return false;
 }
+function clearModuleMocks() {
+  const { clearMocks, mockReset, restoreMocks } = process.__vitest_worker__.config;
+  if (restoreMocks)
+    vi.restoreAllMocks();
+  else if (mockReset)
+    vi.resetAllMocks();
+  else if (clearMocks)
+    vi.clearAllMocks();
+}
 
-export { getTests as a, basename as b, c, dirname as d, ensurePackageInstalled as e, getSuites as f, getNames as g, resolve as h, isAbsolute as i, hasFailed as j, notNullish as k, index as l, interpretOnlyMode as m, noop as n, hasTests as o, partitionSuiteChildren as p, getTasks as q, relative as r, slash as s, toArray as t };
+export { getTasks as A, spyOn as a, vi as b, c, slash as d, ensurePackageInstalled as e, fn as f, getNames as g, getTests as h, isAbsolute as i, dirname as j, basename as k, getSuites as l, resolve as m, noop as n, hasFailed as o, notNullish as p, mergeSlashes as q, relative as r, spies as s, toArray as t, index as u, vitest as v, interpretOnlyMode as w, partitionSuiteChildren as x, hasTests as y, clearModuleMocks as z };

package/dist/utils.js

@@ -1,4 +1,6 @@
-export { e as ensurePackageInstalled, g as getNames, f as getSuites, q as getTasks, a as getTests, j as hasFailed, o as hasTests, m as interpretOnlyMode, n as noop, k as notNullish, p as partitionSuiteChildren, h as resolvePath, s as slash, t as toArray } from './utils-c8e62373.js';
+export { z as clearModuleMocks, e as ensurePackageInstalled, g as getNames, l as getSuites, A as getTasks, h as getTests, o as hasFailed, y as hasTests, w as interpretOnlyMode, q as mergeSlashes, n as noop, p as notNullish, x as partitionSuiteChildren, m as resolvePath, d as slash, t as toArray } from './utils-49e5008c.js';
 import 'local-pkg';
 import 'tty';
 import 'path';
+import 'chai';
+import 'tinyspy';