Mock függvények

Létrehozhatsz egy mock függvényt a vi.fn metódussal, hogy nyomon követhesd a végrehajtását. Ha egy már létező objektumon szeretnél egy metódust nyomon követni, akkor a vi.spyOn metódust használhatod:

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;

A mock eredmények ellenőrzéséhez használj állításokat (pl. toHaveBeenCalled) az expect metóduson. Ez az API referencia leírja a mock viselkedésének beállításához használható tulajdonságokat és metódusokat.

getMockImplementation

• Típus: (...args: any) => any

Visszaadja a mock aktuális implementációját, amennyiben létezik.

Ha a mock a vi.fn segítségével lett létrehozva, akkor a függvénynek átadott függvényt tekinti a mock implementációjának.

Ha a mock a vi.spyOn segítségével lett létrehozva, akkor undefined értéket ad vissza, kivéve, ha egyedi implementációt adtak meg.

getMockName

• Típus: () => string

Ezzel a metódussal lekérdezheted a mock nevét, amit a .mockName(name) metódussal adtál meg.

mockClear

• Típus: () => MockInstance

Törli az összes hívással kapcsolatos információt. A meghívása után a .mock összes tulajdonsága üres lesz. Ez a metódus nem állítja vissza a mock implementációkat. Akkor hasznos, ha a mock-ot különböző állítások között kell tisztítani.

Ha azt szeretnéd, hogy ez a metódus automatikusan meghívásra kerüljön minden teszt előtt, engedélyezd a clearMocks beállítást a konfigurációban.

mockName

• Típus: (name: string) => MockInstance

Beállítja a belső mock nevet. Hasznos, ha sikertelen állítás esetén látni szeretnéd a mock nevét.

mockImplementation

• Típus: (fn: Function) => MockInstance

Átvesz egy függvényt, amely mock implementációként fog szolgálni.

import { vi } from 'vitest';
// ---cut---
const mockFn = vi.fn().mockImplementation(apples => apples + 1);
// vagy: 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

• Típus: (fn: Function) => MockInstance

Átvesz egy függvényt, amelyet a mock implementációjaként fog használni a következő hívás során. Láncolható, így több hívás különböző eredményeket adhat.

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

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

Ha a mockolt függvényhez nincs több mockImplementationOnce implementáció, akkor az alapértelmezett implementációt használja. Az alapértelmezett implementációt a vi.fn(() => defaultValue) vagy a .mockImplementation(() => defaultValue) segítségével lehet beállítani.

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

• Típus: (fn: Function, callback: () => void) => MockInstance
• Típus: (fn: Function, callback: () => Promise<unknown>) => Promise<MockInstance>

Ideiglenesen felülírja az eredeti mock implementációt, amíg a callback végrehajtásra kerül.

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

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

myMockFn(); // 'original'

Használható aszinkron callback-kel is. A metódust meg kell várni (await), hogy utána az eredeti implementáció használható legyen.

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

  // Megvárjuk ezt a hívást, mivel a callback aszinkron
  await myMockFn.withImplementation(
    () => 'temp',
    async () => {
      myMockFn(); // 'temp'
    }
  );

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

Fontos, hogy ez a metódus felülírja a mockImplementationOnce metódussal beállított implementációkat.

mockRejectedValue

• Típus: (value: any) => MockInstance

Átvesz egy értéket, amellyel elutasít, amikor az aszinkron függvényt meghívják.

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

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

mockRejectedValueOnce

• Típus: (value: any) => MockInstance

Átvesz egy értéket, amelyet a következő függvényhívás során elutasít. Ha láncolva van, minden egymást követő hívás a megadott értéket fogja elutasítani.

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

• Típus: () => MockInstance

Ugyanazt csinálja, mint a mockClear, és a belső implementációt egy üres függvénnyé alakítja. Ez törli az összes "once" implementációt is. Akkor hasznos, ha teljesen vissza szeretnéd állítani a mock-ot az alapértelmezett állapotba.

Ha azt szeretnéd, hogy ez a metódus automatikusan meghívásra kerüljön minden teszt előtt, engedélyezheted a mockReset beállítást a konfigurációban.

mockRestore

• Típus: () => MockInstance

A mockReset mellett visszaállítja az eredeti függvény implementációját is.

Ne feledd, hogy a vi.fn()-ből származó mock visszaállítása az implementációt egy üres függvényre állítja, amely undefined értéket ad vissza. A vi.fn(impl) visszaállítása az implementációt az impl-re állítja vissza.

Ha azt szeretnéd, hogy ez a metódus automatikusan meghívásra kerüljön minden teszt előtt, engedélyezheted a restoreMocks beállítást a konfigurációban.

mockResolvedValue

• Típus: (value: any) => MockInstance

Elfogad egy értéket, amelyet felold, amikor az aszinkron függvényt meghívják.

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

await asyncMock(); // 42

mockResolvedValueOnce

• Típus: (value: any) => MockInstance

Elfogad egy értéket, amelyet a következő függvényhívás során felold. Ha láncolva van, minden egymást követő hívás a megadott értéket fogja feloldani.

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

• Típus: () => MockInstance

Akkor használd ezt, ha vissza kell adnod a this kontextust a metódusból a tényleges implementáció meghívása nélkül. Ez egy rövidítés a következőhöz:

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

mockReturnValue

• Típus: (value: any) => MockInstance

Elfogad egy értéket, amelyet visszaad, amikor a mock függvényt meghívják.

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

mockReturnValueOnce

• Típus: (value: any) => MockInstance

Elfogad egy értéket, amelyet a következő függvényhívás során visszaad. Ha láncolva van, minden egymást követő hívás a megadott értéket fogja visszaadni.

Ha nincsenek többé mockReturnValueOnce értékek, a mock visszalép a korábban definiált implementációhoz, ha van ilyen.

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

Ez egy tömb, amely minden egyes hívás összes argumentumát tartalmazza. A tömb egy eleme az adott hívás argumentumait reprezentálja.

const fn = vi.fn();

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

fn.mock.calls ===
  [
    ['arg1', 'arg2'], // first call
    ['arg3'], // second call
  ];

mock.lastCall

Ez az utolsó hívás argumentumait tartalmazza. Ha a mock-ot nem hívták meg, akkor undefined értéket ad vissza.

mock.results

Ez egy tömb, amely az összes értéket tartalmazza, amelyet a függvény visszaadott. A tömb egy eleme egy objektum, amelynek type és value tulajdonságai vannak. A rendelkezésre álló típusok:

• 'return' - a függvény kivétel nélkül tért vissza.
• 'throw' - a függvény egy értéket dobott.

A value tulajdonság a visszaadott értéket vagy a dobott hibát tartalmazza. Ha a függvény egy promise-t adott vissza, akkor a value a feloldott érték lesz, nem a tényleges Promise, hacsak nem oldották fel soha.

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

const result = fn(); // returned 'result'

try {
  fn(); // threw Error
} catch {}

fn.mock.results ===
  [
    // first result
    {
      type: 'return',
      value: 'result',
    },
    // last result
    {
      type: 'throw',
      value: Error,
    },
  ];

mock.invocationCallOrder

A mock végrehajtásának sorrendje. Ez egy számtömböt ad vissza, amelyet az összes definiált mock megoszt.

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

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

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

mock.instances

Ez egy tömb, amely az összes példányt tartalmazza, amelyet a mock a new kulcsszóval történő meghívásakor példányosított. Ne feledd, hogy ez a függvény tényleges kontextusa (this), nem pedig a visszatérési érték.

WARNING

Ha a mock-ot a new MyClass() segítségével példányosították, akkor a mock.instances egy egyetlen értékkel rendelkező tömb lesz:

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

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

Ha egy értéket adsz vissza a konstruktorból, az nem lesz a instances tömbben, hanem a results tömbben:

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

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