Mock funkce

Můžete vytvořit mockovací funkci pro sledování jejího provádění pomocí metody vi.fn. Pokud chcete sledovat metodu existujícího objektu, můžete použít metodu vi.spyOn:

import { vi } from 'vitest';

const fn = vi.fn();
fn('hello world');
fn.mock.calls[0] === ['hello world'];

const market = {
  getApples: () => 100,
};

const getApplesSpy = vi.spyOn(market, 'getApples');
market.getApples();
getApplesSpy.mock.calls.length === 1;

Pro ověření chování mock funkce byste měli použít mock aserce (například toHaveBeenCalled) s expect. Následující API popisuje dostupné vlastnosti a metody pro manipulaci s chováním mock funkce.

getMockImplementation

• Typ: (...args: any) => any

Vrací aktuální implementaci mockovací funkce, pokud je definována.

Pokud byla mockovací funkce vytvořena pomocí vi.fn, bude předaná funkce považována za implementaci mockovací funkce.

Pokud byla mockovací funkce vytvořena pomocí vi.spyOn, vrátí undefined, pokud nebyla poskytnuta vlastní implementace.

getMockName

• Typ: () => string

Vrací jméno, které bylo přiřazeno mock funkci pomocí metody .mockName(name).

mockClear

• Typ: () => MockInstance

Vymaže veškeré informace o každém volání. Po zavolání této metody budou všechny vlastnosti v .mock vracet prázdný stav. Tato metoda neresetuje implementaci. Je užitečná, pokud potřebujete vyčistit mock funkci mezi jednotlivými asercemi.

Pokud chcete, aby byla tato metoda volána automaticky před každým testem, povolte nastavení clearMocks v konfiguraci.

mockName

• Typ: (name: string) => MockInstance

Nastaví interní název mock funkce. Je užitečné pro zobrazení názvu mockovací funkce, pokud aserce selže.

mockImplementation

• Typ: (fn: Function) => MockInstance

Přijímá funkci, která bude použita jako implementace mockovací funkce.

import { vi } from 'vitest';
// ---cut---
const mockFn = vi.fn().mockImplementation(apples => apples + 1);
// or: vi.fn(apples => apples + 1);

const NelliesBucket = mockFn(0);
const BobsBucket = mockFn(1);

NelliesBucket === 1; // true
BobsBucket === 2; // true

mockFn.mock.calls[0][0] === 0; // true
mockFn.mock.calls[1][0] === 1; // true

mockImplementationOnce

• Typ: (fn: Function) => MockInstance

Přijímá funkci, která bude použita jako implementace mockovací funkce pro následující volání. Může být zřetězena, takže více volání funkce produkuje různé výsledky.

import { vi } from 'vitest';
// ---cut---
const myMockFn = vi
  .fn()
  .mockImplementationOnce(() => true)
  .mockImplementationOnce(() => false);

myMockFn(); // true
myMockFn(); // false

Když mockovaná funkce vyčerpá implementace nastavené pomocí mockImplementationOnce, použije výchozí implementaci, která byla nastavena pomocí vi.fn(() => defaultValue) nebo .mockImplementation(() => defaultValue), pokud byly volány:

import { vi } from 'vitest';
// ---cut---
const myMockFn = vi
  .fn(() => 'default')
  .mockImplementationOnce(() => 'first call')
  .mockImplementationOnce(() => 'second call');

// 'first call', 'second call', 'default', 'default'
console.log(myMockFn(), myMockFn(), myMockFn(), myMockFn());

withImplementation

• Typ: (fn: Function, callback: () => void) => MockInstance
• Typ: (fn: Function, callback: () => Promise<unknown>) => Promise<MockInstance>

Dočasně přepíše původní implementaci mockovací funkce po dobu provádění callbacku.

import { vi } from 'vitest';
// ---cut---
const myMockFn = vi.fn(() => 'original');

myMockFn.withImplementation(
  () => 'temp',
  () => {
    myMockFn(); // 'temp'
  }
);

myMockFn(); // 'original'

Může být použita s asynchronním callbackem. Na metodu se musí počkat (await), aby se po dokončení callbacku obnovila původní implementace.

test('async callback', () => {
  const myMockFn = vi.fn(() => 'original');

  // We await this call since the callback is async
  await myMockFn.withImplementation(
    () => 'temp',
    async () => {
      myMockFn(); // 'temp'
    }
  );

  myMockFn(); // 'original'
});

Všimněte si, že tato metoda má přednost před mockImplementationOnce.

mockRejectedValue

• Typ: (value: any) => MockInstance

Přijímá hodnotu, kterou bude promise zamítnuta, když je volána asynchronní funkce.

import { vi } from 'vitest';
// ---cut---
const asyncMock = vi.fn().mockRejectedValue(new Error('Async error'));

await asyncMock(); // throws "Async error"

mockRejectedValueOnce

• Typ: (value: any) => MockInstance

Přijímá hodnotu, kterou bude promise zamítnuta během příštího volání funkce. Pokud je zřetězena, každé po sobě jdoucí volání zamítne specifikovanou hodnotu.

import { vi } from 'vitest';
// ---cut---
const asyncMock = vi
  .fn()
  .mockResolvedValueOnce('first call')
  .mockRejectedValueOnce(new Error('Async error'));

await asyncMock(); // first call
await asyncMock(); // throws "Async error"

mockReset

• Typ: () => MockInstance

Provede operaci mockClear a nastaví vnitřní implementaci na prázdnou funkci (která při volání vrací undefined). Tím se také resetují všechny implementace "once". To je užitečné, když chcete zcela resetovat mock funkci do výchozího stavu.

Pokud chcete, aby byla tato metoda volána automaticky před každým testem, povolte nastavení mockReset v konfiguraci.

mockRestore

• Typ: () => MockInstance

Provede operaci mockReset a obnoví vnitřní implementaci na původní funkci.

Všimněte si, že obnovení mock funkce vytvořené pomocí vi.fn() nastaví implementaci na prázdnou funkci, která vrací undefined. Obnovení vi.fn(impl) obnoví implementaci na impl.

Pokud chcete, aby byla tato metoda volána automaticky před každým testem, povolte nastavení restoreMocks v konfiguraci.

mockResolvedValue

• Typ: (value: any) => MockInstance

Přijímá hodnotu, kterou bude promise vyřešena, když je volána asynchronní funkce.

import { vi } from 'vitest';
// ---cut---
const asyncMock = vi.fn().mockResolvedValue(42);

await asyncMock(); // 42

mockResolvedValueOnce

• Typ: (value: any) => MockInstance

Přijímá hodnotu, kterou bude promise vyřešena během příštího volání funkce. Pokud je zřetězena, každé po sobě jdoucí volání vyřeší zadanou hodnotu.

import { vi } from 'vitest';
// ---cut---
const asyncMock = vi
  .fn()
  .mockResolvedValue('default')
  .mockResolvedValueOnce('first call')
  .mockResolvedValueOnce('second call');

await asyncMock(); // first call
await asyncMock(); // second call
await asyncMock(); // default
await asyncMock(); // default

mockReturnThis

• Typ: () => MockInstance

Použijte to, pokud potřebujete vrátit kontext this z metody bez vyvolání skutečné implementace. Toto je zkrácený zápis pro:

spy.mockImplementation(function () {
  return this;
});

mockReturnValue

• Typ: (value: any) => MockInstance

Přijímá hodnotu, která bude vrácena, kdykoli je volána mockovací funkce.

import { vi } from 'vitest';
// ---cut---
const mock = vi.fn();
mock.mockReturnValue(42);
mock(); // 42
mock.mockReturnValue(43);
mock(); // 43

mockReturnValueOnce

• Typ: (value: any) => MockInstance

Přijímá hodnotu, která bude vrácena během příštího volání funkce. Pokud je zřetězena, každé po sobě jdoucí volání vrátí zadanou hodnotu.

Když už nejsou k dispozici žádné hodnoty mockReturnValueOnce, mockovací funkce se vrátí k dříve definované implementaci, pokud existuje.

import { vi } from 'vitest';
// ---cut---
const myMockFn = vi
  .fn()
  .mockReturnValue('default')
  .mockReturnValueOnce('first call')
  .mockReturnValueOnce('second call');

// 'first call', 'second call', 'default', 'default'
console.log(myMockFn(), myMockFn(), myMockFn(), myMockFn());

mock.calls

Toto je pole obsahující argumenty pro každé volání mock funkce. Každá položka pole představuje argumenty daného volání.

const fn = vi.fn();

fn('arg1', 'arg2');
fn('arg3');

fn.mock.calls ===
  [
    ['arg1', 'arg2'], // první volání
    ['arg3'], // druhé volání
  ];

mock.lastCall

Toto obsahuje argumenty posledního volání mock funkce. Pokud mock funkce nebyla zavolána, vrátí undefined.

mock.results

Toto je pole obsahující všechny hodnoty, které funkce vrátila. Jedna položka pole je objekt s vlastnostmi type a value. Dostupné typy jsou:

• 'return' - funkce se vrátila bez vyvolání chyby.
• 'throw' - funkce vyvolala výjimku.

Vlastnost value obsahuje vrácenou hodnotu nebo vyvolanou výjimku. Pokud funkce vrátila promise, bude value vyřešená hodnota, nikoli skutečný Promise, pokud nebyl nikdy vyřešen.

const fn = vi
  .fn()
  .mockReturnValueOnce('result')
  .mockImplementationOnce(() => {
    throw new Error('thrown error');
  });

const result = fn(); // vrátilo 'result'

try {
  fn(); // vyvolalo chybu
} catch {}

fn.mock.results ===
  [
    // první výsledek
    {
      type: 'return',
      value: 'result',
    },
    // poslední výsledek
    {
      type: 'throw',
      value: Error,
    },
  ];

mock.invocationCallOrder

Pořadí volání mock funkcí. Toto vrací pole čísel, která jsou sdílena mezi všemi definovanými mock funkcemi.

const fn1 = vi.fn();
const fn2 = vi.fn();

fn1();
fn2();
fn1();

fn1.mock.invocationCallOrder === [1, 3];
fn2.mock.invocationCallOrder === [2];

mock.instances

Toto představuje kontext this funkce, nikoli návratovou hodnotu.

WARNING

Pokud byla mock funkce vytvořena pomocí new MyClass(), bude to pole obsahující jednu hodnotu:

const MyClass = vi.fn();
const a = new MyClass();

MyClass.mock.instances[0] === a;

Pokud konstruktor vrací hodnotu, nebude v poli instances, ale místo toho v poli results:

const Spy = vi.fn(() => ({ method: vi.fn() }));
const a = new Spy();

Spy.mock.instances[0] !== a;
Spy.mock.results[0] === a;