Vi

A Vitest a vi segédfüggvényével kínál segédfüggvényeket. Globálisan elérhető (ha a globals konfiguráció engedélyezve van), vagy importálhatod a vitest-ből:

import { vi } from 'vitest';

vi.advanceTimersByTime

• Típus: (ms: number) => Vitest

  Pontosan úgy működik, mint a runAllTimers, de a megadott milliszekundumok elteltével befejeződik. Például ez az 1, 2, 3 értékeket írja ki, és nem dob hibát:

  let i = 0;
  setInterval(() => console.log(++i), 50);
  
  vi.advanceTimersByTime(150);

vi.advanceTimersByTimeAsync

• Típus: (ms: number) => Promise<Vitest>

  Pontosan úgy működik, mint a runAllTimersAsync, de a megadott milliszekundumok elteltével befejeződik. Ez magában foglalja az aszinkron módon beállított időzítőket is. Például ez az 1, 2, 3 értékeket írja ki, és nem dob hibát:

  let i = 0;
  setInterval(() => Promise.resolve().then(() => console.log(++i)), 50);
  
  await vi.advanceTimersByTimeAsync(150);

vi.advanceTimersToNextTimer

• Típus: () => Vitest

  A következő esedékes időzítőt aktiválja. Hasznos, ha állításokat szeretnél tenni az egyes időzítőhívások között. Láncoltan hívhatod meg az időzítők manuális kezeléséhez.

  let i = 0;
  setInterval(() => console.log(++i), 50);
  
  vi.advanceTimersToNextTimer() // log 1
    .advanceTimersToNextTimer() // log 2
    .advanceTimersToNextTimer(); // log 3

vi.advanceTimersToNextTimerAsync

• Típus: () => Promise<Vitest>

  A következő esedékes időzítőt aktiválja, még akkor is, ha az aszinkron módon lett beállítva. Hasznos, ha állításokat szeretnél tenni az egyes időzítőhívások között. Láncoltan hívhatod meg az időzítők manuális kezeléséhez.

  let i = 0;
  setInterval(() => Promise.resolve().then(() => console.log(++i)), 50);
  
  vi.advanceTimersToNextTimerAsync() // log 1
    .advanceTimersToNextTimerAsync() // log 2
    .advanceTimersToNextTimerAsync(); // log 3

vi.getTimerCount

• Típus: () => number

  Lekéri a várakozó időzítők számát.

vi.clearAllMocks

Meghívja a .mockClear() metódust az összes mock objektumra. Ez törli a mockolt hívásokat, de nem állítja vissza az alapértelmezett implementációt.

vi.clearAllTimers

Eltávolítja az összes futásra ütemezett időzítőt. Ezek az időzítők a jövőben soha nem fognak futni.

vi.dynamicImportSettled

Megvárja az összes dinamikus import betöltését. Hasznos, ha van egy szinkron hívásod, amely elindít egy modul importálását, amelyet egyébként nem tudnál megvárni.

vi.fn

• Típus: (fn?: Function) => Mock

  Egy függvény figyelését állítja be, de függvény nélkül is inicializálható. Minden alkalommal, amikor egy függvény meghívásra kerül, tárolja a hívási argumentumait, a visszatérési értékeit és a példányait. Ezenkívül a metódusokkal manipulálhatod a viselkedését. Ha nincs megadva függvény, a mock undefined értéket ad vissza, amikor meghívják.

  const getApples = vi.fn(() => 0);
  
  getApples();
  
  expect(getApples).toHaveBeenCalled();
  expect(getApples).toHaveReturnedWith(0);
  
  getApples.mockReturnValueOnce(5);
  
  const res = getApples();
  expect(res).toBe(5);
  expect(getApples).toHaveNthReturnedWith(2, 5);

vi.getMockedSystemTime

• Típus: () => Date | null

  Visszaadja a setSystemTime segítségével beállított mockolt aktuális dátumot. Ha a dátum nincs mockolva, akkor null értéket ad vissza.

vi.getRealSystemTime

• Típus: () => number

  A vi.useFakeTimers használatakor a Date.now hívások mockolva vannak. Ha valós időt szeretnél lekérni milliszekundumokban, meghívhatod ezt a függvényt.

vi.hoisted

• Típus: <T>(factory: () => T) => T

• Verzió: Vitest 0.31.0 óta

  Az ES modulokban lévő összes statikus import utasítás a fájl tetejére van felhúzva, így az importok előtt definiált kód valójában az importok kiértékelése után kerül végrehajtásra.

  Azonban hasznos lehet valamilyen mellékhatás kiváltása, például a dátumok mockolása egy modul importálása előtt.

  A korlátozás elkerüléséhez átírhatod a statikus importokat dinamikus importokká, például így:

  callFunctionWithSideEffect()
  - import { value } from './some/module.ts'
  + const { value } = await import('./some/module.ts')

  A vitest futtatásakor ezt automatikusan megteheted a vi.hoisted metódus használatával.

  - callFunctionWithSideEffect()
  import { value } from './some/module.ts'
  + vi.hoisted(() => callFunctionWithSideEffect())

  Ez a metódus visszaadja a gyártófüggvény által visszaadott értéket. Ezt az értéket felhasználhatod a vi.mock factory-kben, ha könnyen hozzá szeretnél férni a helyben definiált változókhoz:

  import { expect, vi } from 'vitest';
  import { originalMethod } from './path/to/module.js';
  
  const { mockedMethod } = vi.hoisted(() => {
    return { mockedMethod: vi.fn() };
  });
  
  vi.mock('./path/to/module.js', () => {
    return { originalMethod: mockedMethod };
  });
  
  mockedMethod.mockReturnValue(100);
  expect(originalMethod()).toBe(100);

vi.mock

• Típus: (path: string, factory?: () => unknown) => void

  A megadott path-ból származó összes importált modult egy másik modullal helyettesíti. A path-on belül használhatod a konfigurált Vite aliasokat. A vi.mock hívása fel van húzva (hoisted), így nem számít, hol hívod meg. Mindig az összes import előtt kerül végrehajtásra. Ha a hatókörén kívül eső változókra kell hivatkoznod, definiálhatod azokat a vi.hoisted belsejében, és hivatkozhatsz rájuk a vi.mock belsejében.

  WARNING

  A vi.mock csak azokkal a modulokkal működik, amelyeket az import kulcsszóval importáltak. A require-rel nem működik.

  A Vitest statikusan elemzi a fájlokat a vi.mock felhúzásához (hoisting). Ez azt jelenti, hogy nem használhatsz olyan vi-t, amelyet nem közvetlenül a vitest csomagból importáltál (például valamilyen segédfájlból). Ennek javításához mindig a vitest-ből importált vi-vel használd a vi.mock-ot, vagy engedélyezd a globals konfigurációs opciót.

  WARNING

  A modulok mockolása jelenleg nem támogatott a böngésző módban. Nyomon követheted ezt a funkciót a GitHub issue-ban.

  Ha a factory definiálva van, az összes import visszaadja az eredményét. A Vitest csak egyszer hívja meg a factory-t, és az eredményt az összes későbbi import számára gyorsítótárazza a vi.unmock vagy a vi.doUnmock meghívásáig.

  A jest-től eltérően a factory aszinkron is lehet, így használhatod a vi.importActual vagy egy segédfüggvényt, amelyet első argumentumként kapsz meg, hogy lekérd az eredeti modult.

  vi.mock('./path/to/module.js', async importOriginal => {
    const mod = await importOriginal();
    return {
      ...mod,
      // replace some exports
      namedExport: vi.fn(),
    };
  });

  WARNING

  A vi.mock fel van húzva (más szóval, áthelyezve) a fájl tetejére. Ez azt jelenti, hogy bárhol is írod (legyen az a beforeEach vagy a test belsejében), valójában azelőtt kerül meghívásra.

  Ez azt jelenti, hogy nem használhatsz olyan változókat a factory belsejében, amelyek a factory-n kívül lettek definiálva.

  Ha változókat kell használnod a factory belsejében, próbáld ki a vi.doMock metódust. Ugyanúgy működik, de nincs felhúzva (hoisted). Ügyelj arra, hogy csak a későbbi importokat mockolja.

  Hivatkozhatsz a vi.hoisted metódus által definiált változókra is, ha az a vi.mock előtt lett deklarálva:

  import { namedExport } from './path/to/module.js';
  
  const mocks = vi.hoisted(() => {
    return {
      namedExport: vi.fn(),
    };
  });
  
  vi.mock('./path/to/module.js', () => {
    return {
      namedExport: mocks.namedExport,
    };
  });
  
  vi.mocked(namedExport).mockReturnValue(100);
  
  expect(namedExport()).toBe(100);
  expect(namedExport).toBe(mocks.namedExport);

  WARNING

  Ha egy modult alapértelmezett exporttal mockolsz, akkor a visszaadott factory függvény objektumban egy default kulcsot kell megadnod. Ez egy ES modulokra jellemző sajátosság, ezért a jest dokumentációja eltérhet, mivel a jest CommonJS modulokat használ. Például:

  vi.mock('./path/to/module.js', () => {
    return {
      default: { myDefaultKey: vi.fn() },
      namedExport: vi.fn(),
      // etc...
    };
  });

  Ha van egy __mocks__ mappa egy mockolt fájl mellett, és a factory nincs megadva, a Vitest megpróbálja megkeresni ugyanazzal a névvel rendelkező fájlt a __mocks__ almappában, és azt fogja használni tényleges modulként. Ha egy függőséget mockolsz, a Vitest megpróbálja megkeresni a __mocks__ mappát a projekt gyökerében (alapértelmezés szerint process.cwd()). A deps.moduleDirectories konfigurációs opcióval megadhatod a Vitest számára, hogy hol találhatók a függőségek.

  Például a következő fájlstruktúrád van:

  - __mocks__
    - axios.js
  - src
    __mocks__
      - increment.js
    - increment.js
  - tests
    - increment.test.js

  Ha meghívod a vi.mock-ot egy tesztfájlban factory megadása nélkül, akkor megkeres egy fájlt a __mocks__ mappában, amelyet modulként használhat:

  // increment.test.js
  import { vi } from 'vitest';
  
  // axios is a default export from `__mocks__/axios.js`
  import axios from 'axios';
  
  // increment is a named export from `src/__mocks__/increment.js`
  import { increment } from '../increment.js';
  
  vi.mock('axios');
  vi.mock('../increment.js');
  
  axios.get(`/apples/${increment(1)}`);

  WARNING

  Ügyelj arra, hogy ha nem hívod meg a vi.mock-ot, a modulok nincsenek automatikusan mockolva. A Jest automatikus mockolási viselkedésének replikálásához meghívhatod a vi.mock-ot minden szükséges modulhoz a setupFiles belsejében.

  Ha nincs __mocks__ mappa vagy factory megadva, a Vitest importálja az eredeti modult, és automatikusan mockolja az összes exportját. Az alkalmazott szabályokért lásd az algoritmust.

vi.doMock

• Típus: (path: string, factory?: () => unknown) => void

  Ugyanaz, mint a vi.mock, de nincs felhúzva (hoisted) a fájl tetejére, így hivatkozhatsz változókra a globális fájl hatókörében. A modul következő dinamikus importja fog mockolni. Ez nem fogja mockolni azokat a modulokat, amelyeket a hívás előtt importáltak.

// ./increment.js
export function increment(number) {
  return number + 1;
}

import { beforeEach, test } from 'vitest';
import { increment } from './increment.js';

// the module is not mocked, because vi.doMock is not called yet
increment(1) === 2;

let mockedIncrement = 100;

beforeEach(() => {
  // you can access variables inside a factory
  vi.doMock('./increment.js', () => ({ increment: () => ++mockedIncrement }));
});

test('importing the next module imports mocked one', async () => {
  // original import WAS NOT MOCKED, because vi.doMock is evaluated AFTER imports
  expect(increment(1)).toBe(2);
  const { increment: mockedIncrement } = await import('./increment.js');
  // az új dinamikus import mockolt modult eredményez
  expect(mockedIncrement(1)).toBe(101);
  expect(mockedIncrement(1)).toBe(102);
  expect(mockedIncrement(1)).toBe(103);
});

vi.mocked

• Típus: <T>(obj: T, deep?: boolean) => MaybeMockedDeep<T>

• Típus: <T>(obj: T, options?: { partial?: boolean; deep?: boolean }) => MaybePartiallyMockedDeep<T>

  Típus segéd a TypeScripthez. A valóságban csak a paraméterként átadott objektumot adja vissza.

  Ha a partial értéke true, akkor egy Partial<T> értéket vár vissza.

  import example from './example.js';
  
  vi.mock('./example.js');
  
  test('1+1 equals 2', async () => {
    vi.mocked(example.calc).mockRestore();
  
    const res = example.calc(1, '+', 1);
  
    expect(res).toBe(2);
  });

vi.importActual

• Típus: <T>(path: string) => Promise<T>

  Importálja a modult, megkerülve az összes ellenőrzést, hogy mockolni kell-e. Hasznos lehet, ha részlegesen szeretnél mockolni egy modult.

  vi.mock('./example.js', async () => {
    const axios = await vi.importActual('./example.js');
  
    return { ...axios, get: vi.fn() };
  });

vi.importMock

• Típus: <T>(path: string) => Promise<MaybeMockedDeep<T>>

  Importál egy modult az összes tulajdonságával (beleértve a beágyazott tulajdonságokat is) mockolva. Ugyanazokat a szabályokat követi, mint a vi.mock. Az alkalmazott szabályokért lásd az algoritmust.

vi.resetAllMocks

Meghívja a .mockReset() metódust az összes mock objektumra. Ez törli a mockolt hívásokat, és visszaállítja az implementációt egy üres függvényre (ami undefined értéket ad vissza).

vi.resetConfig

• Típus: RuntimeConfig

  Ha a vi.setConfig korábban meg lett hívva, ez visszaállítja a konfigurációt az eredeti állapotba.

vi.resetModules

• Típus: () => Vitest

  Visszaállítja a modulok regisztrációját az összes modul gyorsítótárának törlésével. Ez lehetővé teszi a modulok újraértékelését, amikor újraimportálják őket. A legfelső szinten importált modulok nem értékelhetők újra. Hasznos lehet a modulok elkülönítésére, ahol a helyi állapot ütközik a tesztek között.

  import { vi } from 'vitest';
  
  import { data } from './data.js'; // Will not get reevaluated beforeEach test
  
  beforeEach(() => {
    vi.resetModules();
  });
  
  test('change state', async () => {
    const mod = await import('./some/path.js'); // Will get reevaluated
    mod.changeLocalState('new value');
    expect(mod.getLocalState()).toBe('new value');
  });
  
  test('module has old state', async () => {
    const mod = await import('./some/path.js'); // Will get reevaluated
    expect(mod.getLocalState()).toBe('old value');
  });

WARNING

Nem állítja vissza a mockolt objektumokat. A mockolt objektumok törléséhez használd a vi.unmock vagy a vi.doUnmock metódust.

vi.restoreAllMocks

Meghívja a .mockRestore() metódust az összes mock objektumra. Ez törli a mockolt hívásokat, és visszaállítja az implementációt az eredeti állapotba.

vi.stubEnv

• Típus: (name: string, value: string) => Vitest

• Verzió: Vitest 0.26.0 óta

  Beállítja a környezeti változó értékét a process.env-ben és az import.meta.env-ben. Az értékét visszaállíthatod a vi.unstubAllEnvs meghívásával.

import { vi } from 'vitest';

// a `process.env.NODE_ENV` és az `import.meta.env.NODE_ENV`
// "development" értékű a "vi.stubEnv" meghívása előtt

vi.stubEnv('NODE_ENV', 'production');

process.env.NODE_ENV === 'production';
import.meta.env.NODE_ENV === 'production';
// a többi változót érintetlen hagyja
import.meta.env.MODE === 'development';

TIP

Az értéket egyszerűen hozzárendeléssel is megváltoztathatod, de nem fogod tudni használni a vi.unstubAllEnvs-t az előző érték visszaállításához:

import.meta.env.MODE = 'test';

vi.unstubAllEnvs

• Típus: () => Vitest

• Verzió: Vitest 0.26.0 óta

  Visszaállítja az import.meta.env és process.env környezeti változók értékeit, amelyeket a vi.stubEnv segítségével módosítottak. A Vitest az első híváskor megjegyzi az eredeti értékeket, és addig tárolja őket, amíg az unstubAllEnvs függvényt meg nem hívják.

import { vi } from 'vitest';

// A `process.env.NODE_ENV` és az `import.meta.env.NODE_ENV`
// értéke "development" a stubEnv meghívása előtt

vi.stubEnv('NODE_ENV', 'production');

process.env.NODE_ENV === 'production';
import.meta.env.NODE_ENV === 'production';

vi.stubEnv('NODE_ENV', 'staging');

process.env.NODE_ENV === 'staging';
import.meta.env.NODE_ENV === 'staging';

vi.unstubAllEnvs();

// visszaállítja az első "stubEnv" hívás előtt tárolt értékre
process.env.NODE_ENV === 'development';
import.meta.env.NODE_ENV === 'development';

vi.stubGlobal

• Típus: (name: string | number | symbol, value: unknown) => Vitest

  Megváltoztatja egy globális változó értékét. Az eredeti értéket a vi.unstubAllGlobals meghívásával lehet visszaállítani.

import { vi } from 'vitest';

// Az `innerWidth` értéke "0" a stubGlobal meghívása előtt

vi.stubGlobal('innerWidth', 100);

innerWidth === 100;
globalThis.innerWidth === 100;
// ha jsdom-ot vagy happy-dom-ot használ
window.innerWidth === 100;

TIP

Az értéket közvetlenül is módosíthatja a globalThis vagy window (ha jsdom/happy-dom környezet van) használatával, de nem fogja tudni használni a vi.unstubAllGlobals-t az eredeti érték visszaállításához:

globalThis.innerWidth = 100;
// ha jsdom-ot vagy happy-dom-ot használ
window.innerWidth = 100;

vi.unstubAllGlobals

• Típus: () => Vitest

• Verzió: Vitest 0.26.0 óta

  Visszaállítja az összes globális változó értékét a globalThis/global objektumokon (és a window/top/self/parent objektumokon, ha jsdom vagy happy-dom környezetet használ), amelyeket a vi.stubGlobal segítségével módosítottak. Amikor először meghívják, a Vitest megjegyzi az eredeti értékeket, és addig tárolja azokat, amíg az unstubAllGlobals újra meg nem hívják.

import { vi } from 'vitest';

const Mock = vi.fn();

// Az IntersectionObserver "undefined" a "stubGlobal" meghívása előtt

vi.stubGlobal('IntersectionObserver', Mock);

IntersectionObserver === Mock;
global.IntersectionObserver === Mock;
globalThis.IntersectionObserver === Mock;
// ha jsdom-ot vagy happy-dom-ot használ
window.IntersectionObserver === Mock;

vi.unstubAllGlobals();

globalThis.IntersectionObserver === undefined;
'IntersectionObserver' in globalThis === false;
// ReferenceError-t dob, mert nincs definiálva
IntersectionObserver === undefined;

vi.runAllTicks

• Típus: () => Vitest

  Meghív minden mikrofeladatot, amelyet a process.nextTick sorba állított. Ez a felhasználó által ütemezett összes mikrofeladatot is futtatja.

vi.runAllTimers

• Típus: () => Vitest

  Ez a metódus minden elindított időzítőt lefuttat, amíg az időzítők sora üres nem lesz. Ez azt jelenti, hogy a runAllTimers során meghívott összes időzítő futni fog. Ha végtelen intervallum van, a futás 10 000 próbálkozás után megszakad. Például ez a következőt fogja naplózni: 1, 2, 3:

  let i = 0;
  setTimeout(() => console.log(++i));
  const interval = setInterval(() => {
    console.log(++i);
    if (i === 3) clearInterval(interval);
  }, 50);
  
  vi.runAllTimers();

vi.runAllTimersAsync

• Típus: () => Promise<Vitest>

  Ez a metódus aszinkron módon meghívja az összes elindított időzítőt, amíg az időzítők sora üres nem lesz. Ez azt jelenti, hogy a runAllTimersAsync során meghívott összes időzítő futni fog, beleértve az aszinkron időzítőket is. Ha végtelen intervallum van, a futás 10 000 próbálkozás után megszakad. Például ez a következőt fogja naplózni: result:

  setTimeout(async () => {
    console.log(await Promise.resolve('result'));
  }, 100);
  
  await vi.runAllTimersAsync();

vi.runOnlyPendingTimers

• Típus: () => Vitest

  Ez a metódus minden olyan időzítőt futtat, amelyet a vi.useFakeTimers() hívás után hoztak létre. Nem futtat egyetlen időzítőt sem, amelyet a futása során hoznak létre. Például ez csak az 1-et fogja naplózni:

  let i = 0;
  setInterval(() => console.log(++i), 50);
  
  vi.runOnlyPendingTimers();

vi.runOnlyPendingTimersAsync

• Típus: () => Promise<Vitest>

  Ez a metódus aszinkron módon futtat minden olyan időzítőt, amelyet a vi.useFakeTimers() hívás után hoztak létre, beleértve az aszinkron időzítőket is. Nem futtat egyetlen időzítőt sem, amelyet a futása során hoznak létre. Például ez a következőt fogja naplózni: 2, 3, 3, 1:

  setTimeout(() => {
    console.log(1);
  }, 100);
  setTimeout(() => {
    Promise.resolve().then(() => {
      console.log(2);
      setInterval(() => {
        console.log(3);
      }, 40);
    });
  }, 10);
  
  await vi.runOnlyPendingTimersAsync();

vi.setSystemTime

• Típus: (date: string | number | Date) => void

  Beállítja a rendszer aktuális dátumát a megadott értékre. Minden Date hívás ezt a dátumot adja vissza.

  Hasznos, ha tesztelni kell valamit, ami az aktuális dátumtól függ - például luxon hívások a kódban.

  const date = new Date(1998, 11, 19);
  
  vi.useFakeTimers();
  vi.setSystemTime(date);
  
  expect(Date.now()).toBe(date.valueOf());
  
  vi.useRealTimers();

vi.setConfig

• Típus: RuntimeConfig

  Frissíti az aktuális tesztfájl konfigurációját. Csak azokat az értékeket befolyásolhatja, amelyeket a tesztek futtatásakor használnak.

vi.spyOn

• Típus: <T, K extends keyof T>(object: T, method: K, accessType?: 'get' | 'set') => MockInstance

  Kémkedést hoz létre egy objektum metódusán vagy getter/setterén.

  let apples = 0;
  const cart = {
    getApples: () => 13,
  };
  
  const spy = vi.spyOn(cart, 'getApples').mockImplementation(() => apples);
  apples = 1;
  
  expect(cart.getApples()).toBe(1);
  
  expect(spy).toHaveBeenCalled();
  expect(spy).toHaveReturnedWith(1);

vi.stubGlobal

• Típus: (key: keyof globalThis & Window, value: any) => Vitest

  Értéket állít be egy globális változó számára. Ha jsdom-ot vagy happy-dom-ot használ, akkor az értéket a window objektumon is beállítja.

  További információ a "Globálisok mockolása" szakaszban.

vi.unmock

• Típus: (path: string) => void

  Eltávolítja a modult a mockolt modulok nyilvántartásából. Minden import hívás az eredeti modult adja vissza, még akkor is, ha korábban mockolták. Ez a hívás fel van emelve (áthelyezve) a fájl tetejére, így csak azokat a modulokat fogja unmockolni, amelyeket például a setupFiles-ban definiáltak.

vi.doUnmock

• Típus: (path: string) => void

  Ugyanaz, mint a vi.unmock, de nem kerül a fájl elejére. A modul következő importálása az eredeti modult fogja importálni a mock helyett. Ez nem fogja unmockolni a korábban importált modulokat.

// ./increment.js
export function increment(number) {
  return number + 1;
}

import { increment } from './increment.js';

// az increment már mockolva van, mert a vi.mock fel van emelve
increment(1) === 100;

// ez fel van emelve, és a factory meghívásra kerül az 1. sorban lévő import előtt
vi.mock('./increment.js', () => ({ increment: () => 100 }));

// minden hívás mockolva van, és az `increment` mindig 100-at ad vissza
increment(1) === 100;
increment(30) === 100;

// ez nincs felemelve, így a többi import unmockolt modult fog visszaadni
vi.doUnmock('./increment.js');

// ez MÉG MINDIG 100-at ad vissza, mert a `vi.doUnmock` nem értékeli újra a modult
increment(1) === 100;
increment(30) === 100;

// a következő import unmockolt, most az `increment` az eredeti függvény, amely a count + 1-et adja vissza
const { increment: unmockedIncrement } = await import('./increment.js');

unmockedIncrement(1) === 2;
unmockedIncrement(30) === 31;

vi.useFakeTimers

• Típus: () => Vitest

  Az időzítők mockolásának engedélyezéséhez ezt a metódust kell meghívnia. Ez átveszi az irányítást az időzítők összes további hívása felett (például setTimeout, setInterval, clearTimeout, clearInterval, nextTick, setImmediate, clearImmediate és Date), amíg a vi.useRealTimers() meg nem hívják.

  A nextTick mockolása nem támogatott, ha a Vitestet node:child_process-en belül futtatja a --no-threads használatával. A NodeJS belsőleg a process.nextTick-et használja a node:child_process-ben, és lefagy, ha mockolják. A nextTick mockolása támogatott, ha a Vitestet a --threads használatával futtatja.

  A megvalósítás belsőleg a @sinonjs/fake-timers könyvtáron alapul.

  TIP

  A 0.35.0 verzió óta a vi.useFakeTimers() már nem mockolja automatikusan a process.nextTick-et. Ez továbbra is mockolható, ha megadja az opciót a toFake argumentumban: vi.useFakeTimers({ toFake: ['nextTick'] }).

vi.isFakeTimers

• Típus: () => boolean

• Verzió: Vitest 0.34.5 óta

  true értéket ad vissza, ha a fake időzítők engedélyezve vannak.

vi.useRealTimers

• Típus: () => Vitest

  Amikor az időzítőkkel végzett, meghívhatja ezt a metódust, hogy visszaállítsa a mockolt időzítőket az eredeti implementációikra. A korábban elindított időzítők nem állnak vissza.

vi.waitFor

• Típus: <T>(callback: WaitForCallback<T>, options?: number | WaitForOptions) => Promise<T>
• Verzió: Vitest 0.34.5 óta

Várja meg, amíg a callback sikeresen végrehajtódik. Ha a callback hibát dob, vagy egy elutasított promise-t ad vissza, akkor addig vár, amíg sikeres nem lesz, vagy időtúllépés nem történik.

Ez nagyon hasznos, ha meg kell várnia, amíg egy aszinkron művelet befejeződik, például amikor elindít egy szervert, és meg kell várnia, amíg elindul.

import { expect, test, vi } from 'vitest';
import { createServer } from './server.js';

test('Server started successfully', async () => {
  const server = createServer();

  await vi.waitFor(
    () => {
      if (!server.isReady) throw new Error('Server not started');

      console.log('Server started');
    },
    {
      timeout: 500, // alapértelmezett az 1000
      interval: 20, // alapértelmezett az 50
    }
  );
  expect(server.isReady).toBe(true);
});

Aszinkron callback-ekhez is működik

// @vitest-environment jsdom

import { expect, test, vi } from 'vitest';
import { getDOMElementAsync, populateDOMAsync } from './dom.js';

test('Element exists in a DOM', async () => {
  // start populating DOM
  populateDOMAsync();

  const element = await vi.waitFor(
    async () => {
      // try to get the element until it exists
      const element = (await getDOMElementAsync()) as HTMLElement | null;
      expect(element).toBeTruthy();
      expect(element.dataset.initialized).toBeTruthy();
      return element;
    },
    {
      timeout: 500, // alapértelmezett az 1000
      interval: 20, // alapértelmezett az 50
    }
  );
  expect(element).toBeInstanceOf(HTMLElement);
});

Ha a vi.useFakeTimers használatban van, a vi.waitFor automatikusan meghívja a vi.advanceTimersByTime(interval)-t minden ellenőrző callback-ben.

vi.waitUntil

• Típus: <T>(callback: WaitUntilCallback<T>, options?: number | WaitUntilOptions) => Promise<T>
• Verzió: Vitest 0.34.5 óta

Ez hasonló a vi.waitFor-hoz, de ha a callback hibát dob, a végrehajtás azonnal megszakad, és hibaüzenetet kapunk. Ha a callback hamis értéket ad vissza, a következő ellenőrzés addig folytatódik, amíg igaz értéket nem ad vissza. Ez akkor hasznos, ha valaminek meg kell jelennie a folytatás előtt.

Nézze meg az alábbi példát. A vi.waitUntil segítségével megvárhatjuk, amíg az elem megjelenik az oldalon, majd tehetünk valamit az elemmel.

import { expect, test, vi } from 'vitest';

test('Element render correctly', async () => {
  const element = await vi.waitUntil(() => document.querySelector('.element'), {
    timeout: 500, // alapértelmezett az 1000
    interval: 20, // alapértelmezett az 50
  });

  // do something with the element
  expect(element.querySelector('.element-child')).toBeTruthy();
});