Mock Fonksiyonlar

vi.fn metodu ile yürütülmesini izlemek için bir mock fonksiyonu oluşturabilirsiniz. Önceden oluşturulmuş bir nesnenin metodunu izlemek için vi.spyOn metodunu kullanabilirsiniz:

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;

Sahte fonksiyonun sonucunu doğrulamak için expect üzerinde spy assertion'ları (örneğin, toHaveBeenCalled) kullanmalısınız. Bu API referansı, mock davranışını değiştirmek için mevcut özellikleri ve metotları açıklar.

getMockName

• Tip: () => string

  .mockName(name) metodu ile mock'a verilen adı döndürmek için kullanılır.

mockClear

• Tip: () => MockInstance

  Her çağrı hakkındaki tüm bilgileri temizler. Çağrıldıktan sonra, spy.mock.calls, spy.mock.results boş diziler döndürecektir. Farklı assertion'lar arasında mock'u temizlemeniz gerektiğinde kullanışlıdır.

  Her testten önce otomatik olarak çağrılmasını istiyorsanız, yapılandırmada clearMocks ayarını etkinleştirebilirsiniz.

mockName

• Tip: (name: string) => MockInstance

  Mock fonksiyonun dahili adını ayarlar. Hangi mock fonksiyonunun assertion'ı geçemediğini belirlemek için kullanışlıdır.

mockImplementation

• Tip: (fn: Function) => MockInstance

  Mock'ın implementasyonu olarak kullanılacak bir fonksiyonu kabul eder.

  Örneğin:

  const mockFn = vi.fn().mockImplementation(apples => apples + 1);
  // veya: 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

• Tip: (fn: Function) => MockInstance

  Tek bir çağrı için mock fonksiyonun uygulaması olarak kullanılacak bir fonksiyonu kabul eder. Birden çok fonksiyon çağrısının farklı sonuçlar üretmesi için zincirlenebilir.

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

  Mock'ın implementasyonları tükendiğinde, vi.fn(() => defaultValue) veya .mockImplementation(() => defaultValue) ile ayarlanan varsayılan uygulamayı çağıracaktır:

  const myMockFn = vi
    .fn(() => 'default')
    .mockImplementationOnce(() => 'first call')
    .mockImplementationOnce(() => 'second call');
  
  // 'first call', 'second call', 'default', 'default'
  console.log(myMockFn(), myMockFn(), myMockFn(), myMockFn());

withImplementation

• Tip: (fn: Function, callback: () => void) => MockInstance

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

  Callback çalışırken orijinal mock implementasyonunu geçici olarak geçersiz kılar.

  const myMockFn = vi.fn(() => 'original');
  
  myMockFn.withImplementation(
    () => 'temp',
    () => {
      myMockFn(); // 'temp'
    }
  );
  
  myMockFn(); // 'original'

  Asenkron callback'lerle kullanılabilir. Daha sonra orijinal uygulamayı kullanmak için metodun beklenmesi gerekir.

  test('async callback', () => {
    const myMockFn = vi.fn(() => 'original');
  
    // Callback asenkron olduğu için bu çağrı beklenmelidir
    await myMockFn.withImplementation(
      () => 'temp',
      async () => {
        myMockFn(); // 'temp'
      }
    );
  
    myMockFn(); // 'original'
  });

  Ayrıca, mockImplementationOnce üzerinde daha yüksek önceliğe sahiptir.

mockRejectedValue

• Tip: (value: any) => MockInstance

  Asenkron fonksiyon çağrıldığında bir hatayı reject eder.

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

mockRejectedValueOnce

• Tip: (value: any) => MockInstance

  Mock fonksiyonun tek bir çağrısı için reddedilecek bir değeri kabul eder. Zincirlenirse, her ardışık çağrı geçirilen değeri reddeder.

  const asyncMock = vi
    .fn()
    .mockResolvedValueOnce('first call')
    .mockRejectedValueOnce(new Error('Async error'));
  
  await asyncMock(); // first call
  await asyncMock(); // "Async error" hatası verir

mockReset

• Tip: () => MockInstance

  mockClear'ın yaptığını yapar ve implementasyonu boş bir fonksiyona çevirir (çağrıldığında undefined döndürür). Bu, mock'u tamamen ilk durumuna döndürmek istediğinizde kullanışlıdır.

  Her testten önce otomatik olarak çağrılmasını istiyorsanız, yapılandırmada mockReset ayarını etkinleştirebilirsiniz.

mockRestore

• Tip: () => MockInstance

  mockReset'in yaptığını yapar ve implementasyonu orijinal fonksiyona geri yükler.

  vi.fn()'den mock'u geri yüklemenin, uygulamayı undefined döndüren boş bir fonksiyona ayarlayacağını unutmayın. vi.fn(impl)'yi geri yüklemek, uygulamayı impl'ye geri yükleyecektir.

  Her testten önce otomatik olarak çağrılmasını istiyorsanız, yapılandırmada restoreMocks ayarını etkinleştirebilirsiniz.

mockResolvedValue

• Tip: (value: any) => MockInstance

  Asenkron fonksiyon çağrıldığında resolve edilecek bir değeri kabul eder.

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

mockResolvedValueOnce

• Tip: (value: any) => MockInstance

  Mock fonksiyonun tek bir çağrısı için resolve edilecek bir değeri kabul eder. Zincirlenirse, her ardışık çağrı geçirilen değeri resolve eder.

  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

• Tip: () => MockInstance

  Implementasyonu this bağlamını döndürecek şekilde ayarlar.

mockReturnValue

• Tip: (value: any) => MockInstance

  Mock her çağrıldığında döndürülecek bir değeri kabul eder.

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

mockReturnValueOnce

• Tip: (value: any) => MockInstance

  Mock fonksiyonun tek bir çağrısı için döndürülecek bir değeri kabul eder. Zincirlenirse, her ardışık çağrı geçirilen değeri döndürür. mockReturnValueOnce değerleri tükendiğinde, mockImplementation veya diğer mockReturn* metotları ile tanımlanan fonksiyon çağrılır.

  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

Bu, her çağrı için kullanılan argümanları içeren bir dizidir.

const fn = vi.fn();

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

fn.mock.calls ===
  [
    ['arg1', 'arg2'], // ilk çağrı
    ['arg3', 'arg4'], // ikinci çağrı
  ];

mock.lastCall

Bu, son çağrının argümanlarını içerir. Mock çağrılmadıysa, undefined döndürür.

mock.results

Bu, fonksiyondan döndürülen tüm değerleri içeren bir dizidir. Dizinin bir öğesi, type (tip) ve value (değer) özelliklerine sahip bir nesnedir. Mevcut tipler şunlardır:

• 'return' - fonksiyon hatasız şekilde döndü.
• 'throw' - fonksiyon bir değer fırlattı.

value özelliği, döndürülen değeri veya fırlatılan hatayı içerir. Fonksiyon bir promise döndürdüyse, çözümlendiğinde value özelliği, promise'in resolve ettiği değer olacaktır.

const fn = vi.fn();

const result = fn(); // sonuç döndürüldü

try {
  fn(); // Hata fırlattı
} catch {}

fn.mock.results ===
  [
    // ilk sonuç
    {
      type: 'return',
      value: 'result',
    },
    // son sonuç
    {
      type: 'throw',
      value: Error,
    },
  ];

mock.instances

Bu, mock fonksiyon new anahtar kelimesiyle çağrıldığında oluşturulan tüm örnekleri içeren bir dizidir. Bunun, bir dönüş değeri değil, fonksiyonun this değeri olduğuna dikkat edin.

WARNING

Mock fonksiyon new MyClass() ile örneklendirilirse, mock.instances, tek bir değere sahip bir dizi olacaktır:

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

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

Constructor'dan bir değer döndürürseniz, bu instances dizisinde değil, bunun yerine results içinde olacaktır:

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

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