Mock függvények

A vi.fn metódussal létrehozhatsz egy mock függvényt, amely lehetővé teszi a végrehajtás nyomon követését. Ha egy már létező objektum metódusát szeretnéd megfigyelni, használd a vi.spyOn metódust:

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 megfigyelt függvény eredményeinek ellenőrzéséhez használj kém állításokat (pl. toHaveBeenCalled) az expect függvényen belül. Ez az API referencia leírja a kém viselkedésének befolyásolásához elérhető tulajdonságokat és metódusokat.

getMockName

• Típus: () => string

  Visszaadja a mock nevét, amelyet a .mockName(name) metódussal állítottál be.

mockClear

• Típus: () => MockInstance

  Törli az összes hívással kapcsolatos információt. A hívás után a spy.mock.calls és spy.mock.results üres tömböket ad vissza. Hasznos, ha a kémeket különböző állítások között kell alaphelyzetbe állí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ós fájlban.

mockName

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

  Beállítja a belső mock nevet. Hasznos lehet, ha látni szeretnéd, melyik mock nem teljesítette az elvárásokat.

mockImplementation

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

  Egy függvényt fogad el, amely a mock implementációjaként fog szolgálni.

  Például:

  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

  Egy függvényt fogad el, amelyet a mock implementációjaként fog használni a mock függvény egyetlen hívásához. Láncolható, így az egymást követő hívások különböző eredményeket adhatnak.

  const myMockFn = vi
    .fn()
    .mockImplementationOnce(() => true)
    .mockImplementationOnce(() => false);
  
  myMockFn(); // true
  myMockFn(); // false

  Ha a mock függvényből kifogynak az implementációk, akkor a vi.fn(() => defaultValue) vagy a .mockImplementation(() => defaultValue) hívással beállított alapértelmezett implementáció lesz meghívva, amennyiben be lett állítva:

  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 a callback végrehajtása alatt.

  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, hogy az eredeti implementáció újra használható legyen.

  test('async callback', () => {
    const myMockFn = vi.fn(() => 'original');
  
    // Ezt a hívást megvárjuk, mivel a callback aszinkron
    await myMockFn.withImplementation(
      () => 'temp',
      async () => {
        myMockFn(); // 'temp'
      }
    );
  
    myMockFn(); // 'original'
  });

  Előnyösebb, mint a mockImplementationOnce.

mockRejectedValue

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

  Egy értéket fogad el, amelyet elutasít, amikor az aszinkron függvényt meghívják.

  const asyncMock = vi.fn().mockRejectedValue(new Error('Async error'));
  
  await asyncMock(); // throws "Async error"

mockRejectedValueOnce

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

  Egy értéket fogad el, amelyet elutasít a mock függvény egyetlen hívásához. Ha láncolt, minden egymást követő hívás elutasítja az átadott értéket.

  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 (ami meghívásakor undefined értéket ad vissza). Ez akkor hasznos, ha a mock-ot teljesen vissza szeretnéd állítani az alapértelmezett állapotába.

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

mockRestore

• Típus: () => MockInstance

  Ugyanazt csinálja, mint a mockReset, és visszaállítja a belső implementációt az eredeti függvényre.

  Fontos: a vi.fn() visszaállítása egy üres függvényt hoz létre, ami undefined értéket ad vissza. A vi.fn(impl) visszaállítása az implementációt 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élyezd a restoreMocks beállítást a konfigurációs fájlban.

mockResolvedValue

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

  Egy értéket fogad el, amelyet felold, amikor az aszinkron függvény meghívásra kerül.

  const asyncMock = vi.fn().mockResolvedValue(43);
  
  await asyncMock(); // 43

mockResolvedValueOnce

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

  Egy értéket fogad el, amelyet felold a mock függvény egyetlen hívásához. Ha láncolt, minden egymást követő hívás feloldja az átadott értéket.

  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

  Beállítja a belső implementációt, hogy visszaadja a this kontextust.

mockReturnValue

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

  Egy értéket fogad el, amelyet visszaad, amikor a mock függvény meghívásra kerül.

  const mock = vi.fn();
  mock.mockReturnValue(42);
  mock(); // 42
  mock.mockReturnValue(43);
  mock(); // 43

mockReturnValueOnce

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

  Egy értéket fogad el, amelyet visszaad a mock függvény egyetlen hívásához. Ha láncolt, minden egymást követő hívás visszaadja az átadott értéket. Ha nincsenek többé mockReturnValueOnce értékek, meghívja a mockImplementation vagy más mockReturn* metódusok által meghatározott függvényt.

  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, ami az összes argumentumot tartalmazza minden egyes híváshoz. A tömb minden eleme az adott hívás argumentumait tartalmazza egy tömbben.

const fn = vi.fn();

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

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

mock.lastCall

Ez tartalmazza az utolsó hívás argumentumait. Ha a kém még nem lett meghívva, undefined értéket ad vissza.

mock.results

Ez egy tömb, ami az összes értéket tartalmazza, amit a függvény visszaadott. A tömb egy eleme egy objektum type és value tulajdonságokkal. A lehetséges típusok:

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

A value tulajdonság tartalmazza a visszaadott értéket vagy a dobott hibát. Ha a függvény egy promise-t adott vissza, akkor a feloldás után a value tulajdonság a promise által feloldott érték lesz.

const fn = vi.fn();

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.instances

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

WARNING

Ha a mock a new MyClass()-szal lett példányosítva, akkor a mock.instances egy egyetlen elemet tartalmazó 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 belsejében:

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

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