Vi

Vitest poskytuje užitečné funkce, které vám pomohou prostřednictvím svého pomocníka vi. Můžete k němu přistupovat globálně (pokud je konfigurace globals povolena), nebo importovat z vitest:

import { vi } from 'vitest';

vi.advanceTimersByTime

Typ: (ms: number) => Vitest
Chová se stejně jako runAllTimers, ale skončí po uplynutí zadaného času v milisekundách. Například následující kód zapíše do konzole 1, 2, 3 a nezpůsobí chybu:
ts
```
let i = 0;
setInterval(() => console.log(++i), 50);

vi.advanceTimersByTime(150);
```

vi.advanceTimersByTimeAsync

Typ: (ms: number) => Promise<Vitest>
Chová se stejně jako runAllTimersAsync, ale skončí po uplynutí zadaného času v milisekundách. To zahrnuje i asynchronně nastavené časovače. Například následující kód zapíše do konzole 1, 2, 3 a nezpůsobí chybu:
ts
```
let i = 0;
setInterval(() => Promise.resolve().then(() => console.log(++i)), 50);

await vi.advanceTimersByTimeAsync(150);
```

vi.advanceTimersToNextTimer

Typ: () => Vitest
Spustí další dostupný časovač. Užitečné pro provádění kontrol mezi jednotlivými spuštěními časovačů. Můžete jej řetězově volat a spravovat časovače ručně.
ts
```
let i = 0;
setInterval(() => console.log(++i), 50);

vi.advanceTimersToNextTimer() // log 1
  .advanceTimersToNextTimer() // log 2
  .advanceTimersToNextTimer(); // log 3
```

vi.advanceTimersToNextTimerAsync

Typ: () => Promise<Vitest>
Spustí další dostupný časovač, i když byl nastaven asynchronně. Užitečné pro provádění kontrol mezi jednotlivými spuštěními časovačů. Můžete jej řetězově volat a spravovat časovače ručně.
ts
```
let i = 0;
setInterval(() => Promise.resolve().then(() => console.log(++i)), 50);

vi.advanceTimersToNextTimerAsync() // log 1
  .advanceTimersToNextTimerAsync() // log 2
  .advanceTimersToNextTimerAsync(); // log 3
```

vi.getTimerCount

Typ: () => number
Vrátí počet čekajících časovačů.

vi.clearAllMocks

Zavolá .mockClear() na všechny špiony (spies). Tím se vymaže historie mocků, ale neobnoví se výchozí implementace.

vi.clearAllTimers

Odebere všechny naplánované časovače. Tyto časovače se již nikdy nespustí.

vi.dynamicImportSettled

Počká na dokončení všech dynamických importů. Užitečné, pokud máte synchronní volání, které spouští import modulu, na který jinak nemůžete čekat.

vi.fn

Typ: (fn?: Function) => Mock
Vytvoří špiona (spy) na funkci, a to i bez existující funkce. Pokaždé, když je funkce volána, uloží své argumenty volání, návratové hodnoty a instance. Můžete také manipulovat s jejím chováním pomocí metod. Pokud není zadána žádná funkce, vrátí při volání undefined.
ts
```
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

Typ: () => Date | null
Vrátí aktuální mockované datum, které bylo nastaveno pomocí setSystemTime. Pokud datum není mockované, vrátí null.

vi.getRealSystemTime

Typ: () => number
Při použití vi.useFakeTimers jsou volání Date.now mockována. Pokud potřebujete získat reálný čas v milisekundách, můžete zavolat tuto funkci.

vi.hoisted

Typ: <T>(factory: () => T) => T
Verze: Od Vitest 0.31.0
Všechny statické příkazy import v ES modulech jsou přesunuty na začátek souboru, takže jakýkoli kód, který je definován před importy, bude ve skutečnosti spuštěn až po vyhodnocení importů.
Může však být užitečné vyvolat nějaký vedlejší efekt, jako je mockování dat, ještě před importem modulu.
Chcete-li toto omezení obejít, můžete přepsat statické importy na dynamické, například takto:
diff
```
callFunctionWithSideEffect()
- import { value } from './some/module.ts'
+ const { value } = await import('./some/module.ts')
```
Při spuštění vitest to můžete udělat automaticky pomocí metody vi.hoisted.
diff
```
- callFunctionWithSideEffect()
import { value } from './some/module.ts'
+ vi.hoisted(() => callFunctionWithSideEffect())
```
Tato metoda vrací hodnotu, kterou factory vrátila. Tuto hodnotu můžete použít ve svých továrnách vi.mock, pokud potřebujete snadný přístup k lokálně definovaným proměnným:
ts
```
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

Typ: (path: string, factory?: () => unknown) => void
Nahradí všechny importované moduly ze zadané cesty jiným modulem. Uvnitř cesty můžete použít nakonfigurované aliasy Vite. Volání vi.mock je vyzdviženo (hoisted), takže nezáleží na tom, kde jej voláte. Vždy bude spuštěno před všemi importy. Pokud potřebujete odkazovat na proměnné mimo jeho rozsah, můžete je definovat uvnitř vi.hoisted a použít je v vi.mock.
WARNING
vi.mock lze použít pouze pro moduly, které byly importovány pomocí klíčového slova import. Nefunguje s require.
Vitest staticky analyzuje vaše soubory, aby vyzdvihl vi.mock. To znamená, že nemůžete použít vi, které nebylo importováno přímo z balíčku vitest (například z nějakého pomocného souboru). Chcete-li to opravit, vždy používejte vi.mock s vi importovaným z vitest, nebo povolte konfigurační možnost globals.
WARNING
Mockování modulů není v současné době podporováno v režimu prohlížeče. Tuto funkci můžete sledovat v GitHub issue.
Pokud je definována factory, všechny importy vrátí její výsledek. Vitest volá factory pouze jednou a ukládá výsledek do mezipaměti pro všechny následující importy, dokud není volána vi.unmock nebo vi.doUnmock.
Na rozdíl od jest může být factory asynchronní, takže můžete použít vi.importActual nebo pomocníka, který je obdržen jako první argument, uvnitř, abyste získali původní modul.
ts
```
vi.mock('./path/to/module.js', async importOriginal => {
  const mod = await importOriginal();
  return {
    ...mod,
    // nahradí některé exporty
    namedExport: vi.fn(),
  };
});
```
WARNING
vi.mock je vyzdvižen (jinými slovy, přesunut) na začátek souboru. To znamená, že kdykoli jej napíšete (ať už uvnitř beforeEach nebo test), bude ve skutečnosti volán před tím.
To také znamená, že nemůžete použít žádné proměnné uvnitř factory, které jsou definovány mimo ni.
Pokud potřebujete použít proměnné uvnitř factory, zkuste vi.doMock. Funguje to stejně, ale není vyzdviženo. Mějte na paměti, že mockuje pouze následující importy.
Můžete také odkazovat na proměnné definované metodou vi.hoisted, pokud byla deklarována před vi.mock:
ts
```
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
Pokud mockujete modul s výchozím exportem (default export), budete muset zadat klíč default uvnitř vráceného objektu factory. Toto je specifické omezení pro ES moduly, proto se dokumentace jest může lišit, protože jest používá CommonJS moduly. Například,
ts
```
vi.mock('./path/to/module.js', () => {
  return {
    default: { myDefaultKey: vi.fn() },
    namedExport: vi.fn(),
    // atd...
  };
});
```
Pokud existuje složka __mocks__ vedle souboru, který mockujete, a factory není zadána, Vitest se pokusí najít soubor se stejným názvem v podsložce __mocks__ a použít jej jako skutečný modul. Pokud mockujete závislost, Vitest se pokusí najít složku __mocks__ v kořeni projektu (výchozí je process.cwd()). Můžete říct Vitestu, kde se závislosti nacházejí, prostřednictvím konfigurační možnosti deps.moduleDirectories.
Například, máte tuto strukturu souborů:
```
- __mocks__
  - axios.js
- src
  __mocks__
    - increment.js
  - increment.js
- tests
  - increment.test.js
```
Pokud zavoláte vi.mock v testovacím souboru bez zadané factory, najde soubor ve složce __mocks__, který se použije jako modul:
ts
```
// increment.test.js
import { vi } from 'vitest';

// axios je výchozí export (default export) z `__mocks__/axios.js`
import axios from 'axios';

// increment je pojmenovaný export (named export) z `src/__mocks__/increment.js`
import { increment } from '../increment.js';

vi.mock('axios');
vi.mock('../increment.js');

axios.get(`/apples/${increment(1)}`);
```
WARNING
Mějte na paměti, že pokud nezavoláte vi.mock, moduly nejsou mockovány automaticky. Chcete-li replikovat chování automatického mockování Jestu, můžete zavolat vi.mock pro každý požadovaný modul uvnitř setupFiles.
Pokud neexistuje složka __mocks__ nebo zadaná factory, Vitest importuje původní modul a automaticky mockuje všechny jeho exporty. Pro použitá pravidla viz algoritmus.

vi.doMock

Typ: (path: string, factory?: () => unknown) => void
Stejné jako vi.mock, ale není vyzdviženo na začátek souboru, takže můžete odkazovat na proměnné v globálním rozsahu souboru. Další dynamický import modulu bude mockován. To nebude mockovat moduly, které byly importovány před tímto voláním.

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

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

// modul není mockován, protože vi.doMock ještě nebyl volán
increment(1) === 2;

let mockedIncrement = 100;

beforeEach(() => {
  // můžete přistupovat k proměnným uvnitř factory
  vi.doMock('./increment.js', () => ({ increment: () => ++mockedIncrement }));
});

test('import následujícího modulu načte mockovanou verzi', async () => {
  // původní import NEBYL MOCKOVÁN, protože vi.doMock je vyhodnocen PO importech
  expect(increment(1)).toBe(2);
  const { increment: mockedIncrement } = await import('./increment.js');
  // nový dynamický import vrací mockovaný modul
  expect(mockedIncrement(1)).toBe(101);
  expect(mockedIncrement(1)).toBe(102);
  expect(mockedIncrement(1)).toBe(103);
});

vi.mocked

Typ: <T>(obj: T, deep?: boolean) => MaybeMockedDeep<T>
Typ: <T>(obj: T, options?: { partial?: boolean; deep?: boolean }) => MaybePartiallyMockedDeep<T>
Pomocný typ pro TypeScript. Ve skutečnosti pouze vrací objekt, který byl předán.
Když je partial true, bude očekávat Partial<T> jako návratovou hodnotu.
ts
```
import example from './example.js';

vi.mock('./example.js');

test('1+1 se rovná 2', async () => {
  vi.mocked(example.calc).mockRestore();

  const res = example.calc(1, '+', 1);

  expect(res).toBe(2);
});
```

vi.importActual

Typ: <T>(path: string) => Promise<T>
Importuje modul, obchází všechny kontroly, zda by měl být mockován. Může být užitečné, pokud chcete mockovat modul částečně.
ts
```
vi.mock('./example.js', async () => {
  const axios = await vi.importActual('./example.js');

  return { ...axios, get: vi.fn() };
});
```

vi.importMock

Typ: <T>(path: string) => Promise<MaybeMockedDeep<T>>
Importuje modul se všemi jeho vlastnostmi (včetně vnořených vlastností) mockovanými. Dodržuje stejná pravidla, která dodržuje vi.mock. Pro použitá pravidla viz algoritmus.

vi.resetAllMocks

Zavolá .mockReset() na všechny špiony (spies). Tím se vymaže historie mocků a obnoví se implementace na prázdnou funkci (vrátí undefined).

vi.resetConfig

Typ: RuntimeConfig
Pokud bylo dříve voláno vi.setConfig, obnoví konfiguraci do původního stavu.

vi.resetModules

Typ: () => Vitest

Resetuje registr modulů vymazáním mezipaměti všech modulů. To umožňuje, aby byly moduly znovu vyhodnoceny při opětovném importu. Importy nejvyšší úrovně nelze znovu vyhodnotit. Může být užitečné izolovat moduly, kde dochází ke konfliktům lokálního stavu mezi testy.

import { vi } from 'vitest';

import { data } from './data.js'; // Nebude znovu vyhodnocováno před každým testem

beforeEach(() => {
  vi.resetModules();
});

test('testuje změnu stavu', async () => {
  const mod = await import('./some/path.js'); // Bude znovu vyhodnoceno
  mod.changeLocalState('new value');
  expect(mod.getLocalState()).toBe('new value');
});

test('ověřuje, že modul má původní stav', async () => {
  const mod = await import('./some/path.js'); // Bude znovu vyhodnoceno
  expect(mod.getLocalState()).toBe('old value');
});

WARNING

Neresetuje registr mocků. Chcete-li vymazat registr mocků, použijte vi.unmock nebo vi.doUnmock.

vi.restoreAllMocks

Zavolá .mockRestore() na všechny špiony (spies). Tím se vymaže historie mocků a obnoví se implementace na původní.

vi.stubEnv

Typ: (name: string, value: string) => Vitest
Verze: Od Vitest 0.26.0
Změní hodnotu proměnné prostředí v process.env a import.meta.env. Původní hodnotu můžete obnovit voláním vi.unstubAllEnvs.

import { vi } from 'vitest';

// `process.env.NODE_ENV` a `import.meta.env.NODE_ENV`
// jsou "development" před voláním "vi.stubEnv"

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

process.env.NODE_ENV === 'production';
import.meta.env.NODE_ENV === 'production';
// nemění ostatní proměnné prostředí
import.meta.env.MODE === 'development';

TIP

Hodnotu můžete také změnit jednoduchým přiřazením, ale nebudete moci použít vi.unstubAllEnvs k obnovení předchozí hodnoty:

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

vi.unstubAllEnvs

Typ: () => Vitest
Verze: Od Vitest 0.26.0
Obnoví všechny hodnoty v import.meta.env a process.env, které byly změněny pomocí vi.stubEnv. Při prvním volání si Vitest uloží původní hodnoty a použije je pro obnovení při volání vi.unstubAllEnvs.

import { vi } from 'vitest';

// `process.env.NODE_ENV` a `import.meta.env.NODE_ENV`
// mají hodnotu "development" před voláním `stubEnv`.

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();

// Obnoví hodnoty na ty, které byly uloženy před prvním voláním `stubEnv`.
process.env.NODE_ENV === 'development';
import.meta.env.NODE_ENV === 'development';

vi.stubGlobal

Typ: (name: string | number | symbol, value: unknown) => Vitest
Umožňuje změnit hodnotu globální proměnné. Pro obnovení původní hodnoty použijte funkci vi.unstubAllGlobals.

import { vi } from 'vitest';

// `innerWidth` je "0" před voláním stubGlobal

vi.stubGlobal('innerWidth', 100);

innerWidth === 100;
globalThis.innerWidth === 100;
// pokud používáte prostředí `jsdom` nebo `happy-dom`.
window.innerWidth === 100;

TIP

Hodnotu můžete změnit také jednoduše přiřazením do globalThis nebo window (pokud používáte prostředí jsdom nebo happy-dom), ale nebudete moci použít vi.unstubAllGlobals k obnovení původní hodnoty:

globalThis.innerWidth = 100;
// pokud používáte jsdom nebo happy-dom
window.innerWidth = 100;

vi.unstubAllGlobals

Typ: () => Vitest
Verze: Od Vitest 0.26.0
Obnoví všechny globální hodnoty na globalThis/global (a window/top/self/parent, pokud používáte prostředí jsdom nebo happy-dom), které byly změněny pomocí vi.stubGlobal. Při prvním volání si Vitest uloží původní hodnoty a použije je pro obnovení při volání vi.unstubAllGlobals.

import { vi } from 'vitest';

const Mock = vi.fn();

// IntersectionObserver je "undefined" před voláním "stubGlobal"

vi.stubGlobal('IntersectionObserver', Mock);

IntersectionObserver === Mock;
global.IntersectionObserver === Mock;
globalThis.IntersectionObserver === Mock;
// pokud používáte jsdom nebo happy-dom
window.IntersectionObserver === Mock;

vi.unstubAllGlobals();

globalThis.IntersectionObserver === undefined;
'IntersectionObserver' in globalThis === false;
// vyvolá ReferenceError, protože není definován
IntersectionObserver === undefined;

vi.runAllTicks

Typ: () => Vitest
Spustí všechny mikrotasky, které byly zařazeny do fronty pomocí process.nextTick. Tím se také spustí všechny mikrotasky naplánované těmito mikrotaskami.

vi.runAllTimers

Typ: () => Vitest
Tato metoda provede všechny naplánované časovače, dokud není fronta časovačů prázdná. To znamená, že každý časovač volaný během runAllTimers bude spuštěn. Pokud máte nekonečný interval, vyvolá výjimku po 10 000 pokusech. Například tento kód vypíše 1, 2, 3:
ts
```
let i = 0;
setTimeout(() => console.log(++i));
const interval = setInterval(() => {
  console.log(++i);
  if (i === 3) clearInterval(interval);
}, 50);

vi.runAllTimers();
```

vi.runAllTimersAsync

Typ: () => Promise<Vitest>
Tato metoda asynchronně provede všechny naplánované časovače, dokud není fronta časovačů prázdná. To znamená, že každý časovač volaný během runAllTimersAsync bude spuštěn, a to i asynchronní časovače. Pokud máte nekonečný interval, vyvolá výjimku po 10 000 pokusech. Například tento kód vypíše result:
ts
```
setTimeout(async () => {
  console.log(await Promise.resolve('result'));
}, 100);

await vi.runAllTimersAsync();
```

vi.runOnlyPendingTimers

Typ: () => Vitest
Tato metoda provede všechny časovače naplánované po volání vi.useFakeTimers(). Nespustí žádný časovač, který byl spuštěn během provádění této metody. Například tento kód vypíše pouze 1:
ts
```
let i = 0;
setInterval(() => console.log(++i), 50);

vi.runOnlyPendingTimers();
```

vi.runOnlyPendingTimersAsync

Typ: () => Promise<Vitest>

Tato metoda asynchronně provede všechny časovače naplánované po volání vi.useFakeTimers(), a to i asynchronní. Nespustí žádný časovač, který byl spuštěn během provádění této metody. Například tento kód vypíše 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

Typ: (date: string | number | Date) => void
Nastaví aktuální systémový čas na zadané datum. Všechna volání Date vrátí toto nastavené datum.
Užitečné, pokud potřebujete testovat kód, který závisí na aktuálním datu - například volání luxon uvnitř vašeho kódu.
ts
```
const date = new Date(1998, 11, 19);

vi.useFakeTimers();
vi.setSystemTime(date);

expect(Date.now()).toBe(date.valueOf());

vi.useRealTimers();
```

vi.setConfig

Typ: RuntimeConfig
Aktualizuje konfiguraci pro aktuální testovací soubor. Můžete ovlivnit pouze hodnoty, které se používají při provádění testů.

vi.spyOn

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

Vytvoří spy (špióna) na metodu nebo getter/setter objektu.

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

Typ: (key: keyof globalThis & Window, value: any) => Vitest
Nastaví hodnotu globální proměnné. Pokud používáte jsdom nebo happy-dom, umístí také hodnotu do objektu window.
Přečtěte si více v sekci "Mockování Globals" (Mocking Globals) .

vi.unmock

Typ: (path: string) => void
Odebere modul z mockovaného registru. Všechna volání import vrátí původní modul, i když byl dříve mockován. Toto volání je přesunuto (hoisted) na začátek souboru, takže bude unmockovat pouze moduly, které byly definovány v setupFiles, například.

vi.doUnmock

Typ: (path: string) => void
Stejné jako vi.unmock, ale není přesunuto na začátek souboru. Následující import modulu načte původní modul, nikoli mock. Tím se ale neunmockují dříve importované moduly.

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

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

// increment je již mockován, protože vi.mock je hoisted
increment(1) === 100;

// toto je hoisted a factory je volána před importem na řádku 1
vi.mock('./increment.js', () => ({ increment: () => 100 }));

// všechna volání jsou mockována a `increment` vždy vrací 100
increment(1) === 100;
increment(30) === 100;

// toto není hoisted, takže jiný import vrátí nemockovaný modul
vi.doUnmock('./increment.js');

// toto STÁLE vrací 100, protože `vi.doUnmock` nepřehodnocuje modul
increment(1) === 100;
increment(30) === 100;

// další import je nemockovaný, nyní je `increment` původní funkce, která vrací count + 1
const { increment: unmockedIncrement } = await import('./increment.js');

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

vi.useFakeTimers

Typ: () => Vitest
Pro povolení mockování časovačů musíte zavolat tuto metodu. Přesměruje všechna další volání časovačů (jako jsou setTimeout, setInterval, clearTimeout, clearInterval, nextTick, setImmediate, clearImmediate a Date), dokud není volána vi.useRealTimers().
Mockování nextTick není podporováno při spouštění Vitest uvnitř node:child_process pomocí --no-threads. NodeJS používá process.nextTick interně v node:child_process a při mockování se zablokuje. Mockování nextTick je podporováno při spuštění Vitest s --threads.
Implementace je interně založena na @sinonjs/fake-timers.
TIP
Od verze 0.35.0 vi.useFakeTimers() již automaticky nemockuje process.nextTick. Stále jej lze mockovat specifikováním možnosti v argumentu toFake: vi.useFakeTimers({ toFake: ['nextTick'] }).

vi.isFakeTimers

Typ: () => boolean
Verze: Od Vitest 0.34.5
Vrací true, pokud jsou povoleny falešné časovače.

vi.useRealTimers

Typ: () => Vitest
Po skončení používání falešných časovačů můžete zavolat tuto metodu, abyste vrátili mockované časovače do jejich původních implementací. Všechny časovače, které byly spuštěny dříve, nebudou obnoveny.

vi.waitFor

Typ: <T>(callback: WaitForCallback<T>, options?: number | WaitForOptions) => Promise<T>
Verze: Od Vitest 0.34.5
Čeká na úspěšné provedení callback funkce. Pokud callback vyvolá chybu nebo vrátí odmítnutý promise, bude čekat, dokud se mu to nepodaří nebo nevyprší časový limit.
To je velmi užitečné, když potřebujete počkat, až se dokončí nějaká asynchronní akce, například když spouštíte server a potřebujete počkat, až se spustí.

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, // default is 1000
      interval: 20, // default is 50
    }
  );
  expect(server.isReady).toBe(true);
});

Funguje to i pro asynchronní callbacky.

// @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, // default is 1000
      interval: 20, // default is 50
    }
  );
  expect(element).toBeInstanceOf(HTMLElement);
});

Pokud je použito vi.useFakeTimers, vi.waitFor automaticky volá vi.advanceTimersByTime(interval) v každém kontrolním callbacku.

vi.waitUntil

Typ: <T>(callback: WaitUntilCallback<T>, options?: number | WaitUntilOptions) => Promise<T>
Verze: Od Vitest 0.34.5
To je podobné vi.waitFor, ale pokud callback vyvolá chybu, provádění se okamžitě přeruší a obdrží se chybová zpráva. Pokud callback vrátí hodnotu vyhodnocenou jako false, další kontrola bude pokračovat, dokud se nevrátí hodnota vyhodnocená jako true. To je užitečné, když potřebujete počkat, až něco existuje, než podniknete další krok.
Podívejte se na příklad níže. Můžeme použít vi.waitUntil k čekání na zobrazení prvku na stránce a poté můžeme s prvkem něco udělat.

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

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

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

Vi ​

vi.advanceTimersByTime ​

vi.advanceTimersByTimeAsync ​

vi.advanceTimersToNextTimer ​

vi.advanceTimersToNextTimerAsync ​

vi.getTimerCount ​

vi.clearAllMocks ​

vi.clearAllTimers ​

vi.dynamicImportSettled ​

vi.fn ​

vi.getMockedSystemTime ​

vi.getRealSystemTime ​

vi.hoisted ​

vi.mock ​

vi.doMock ​

vi.mocked ​

vi.importActual ​

vi.importMock ​

vi.resetAllMocks ​

vi.resetConfig ​

vi.resetModules ​

vi.restoreAllMocks ​

vi.stubEnv ​

vi.unstubAllEnvs ​

vi.stubGlobal ​

vi.unstubAllGlobals ​

vi.runAllTicks ​

vi.runAllTimers ​

vi.runAllTimersAsync ​

vi.runOnlyPendingTimers ​

vi.runOnlyPendingTimersAsync ​

vi.setSystemTime ​

vi.setConfig ​

vi.spyOn ​

vi.stubGlobal ​

vi.unmock ​

vi.doUnmock ​

vi.useFakeTimers ​

vi.isFakeTimers ​

vi.useRealTimers ​

vi.waitFor ​

vi.waitUntil ​

Vi

vi.advanceTimersByTime

vi.advanceTimersByTimeAsync

vi.advanceTimersToNextTimer

vi.advanceTimersToNextTimerAsync

vi.getTimerCount

vi.clearAllMocks

vi.clearAllTimers

vi.dynamicImportSettled

vi.fn

vi.getMockedSystemTime

vi.getRealSystemTime

vi.hoisted

vi.mock

vi.doMock

vi.mocked

vi.importActual

vi.importMock

vi.resetAllMocks

vi.resetConfig

vi.resetModules

vi.restoreAllMocks

vi.stubEnv

vi.unstubAllEnvs

vi.stubGlobal

vi.unstubAllGlobals

vi.runAllTicks

vi.runAllTimers

vi.runAllTimersAsync

vi.runOnlyPendingTimers

vi.runOnlyPendingTimersAsync

vi.setSystemTime

vi.setConfig

vi.spyOn

vi.stubGlobal

vi.unmock

vi.doUnmock

vi.useFakeTimers

vi.isFakeTimers

vi.useRealTimers

vi.waitFor

vi.waitUntil