Mock Fonksiyonları

vi.fn metodu ile bir mock fonksiyonu oluşturarak çağrılarını ve davranışını takip edebilirsiniz. Eğer zaten var olan bir nesne üzerindeki belirli bir metodu izlemek istiyorsanız, bunun yerine 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;

Mock sonuçlarını doğrulamak için expect ile birlikte mock doğrulama yöntemlerini (örneğin, toHaveBeenCalled) kullanmalısınız. Bu API referansı, mock davranışını yönetmek için kullanılabilecek mevcut özellikleri ve metodları açıklar.

TIP

Aşağıdaki tiplerde, özel fonksiyon implementasyonu <T> jeneriği ile belirtilmiştir.

getMockImplementation

function getMockImplementation(): T | undefined;

Mevcut mock implementasyonunu (varsa) döndürür.

Eğer mock vi.fn ile oluşturulduysa, sağlanan fonksiyonu mock implementasyonu olarak kullanır.

Eğer mock vi.spyOn ile oluşturulduysa, özel bir implementasyon sağlanmadığı sürece undefined döndürür.

getMockName

function getMockName(): string;

Mock'a .mockName(name) metodu ile atanan adı döndürmek için kullanın. Varsayılan olarak vi.fn() döndürür.

mockClear

function mockClear(): MockInstance<T>;

Her çağrı hakkındaki tüm bilgileri temizler. Çağrıldıktan sonra, .mock üzerindeki tüm özellikler başlangıç durumlarına döner. Bu metod implementasyonları sıfırlamaz. Farklı doğrulamalar arasında mock'ları temizlemek için kullanışlıdır.

Bu metodu her testten önce otomatik olarak çağırmak için, konfigürasyondaki clearMocks ayarını etkinleştirin.

mockName

function mockName(name: string): MockInstance<T>;

Dahili mock adını ayarlar. Bu, bir doğrulama başarısız olduğunda mock'u tanımlamak için kullanışlıdır.

mockImplementation

function mockImplementation(fn: T): MockInstance<T>;

Mock implementasyonu olarak kullanılacak bir fonksiyonu kabul eder. TypeScript, argümanların ve dönüş tipinin orijinal fonksiyonun argümanları ve dönüş tipiyle eşleşmesini bekler.

const mockFn = vi.fn().mockImplementation((apples: number) => 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

function mockImplementationOnce(fn: T): MockInstance<T>;

Mock implementasyonu olarak kullanılacak bir fonksiyonu kabul eder. TypeScript, argümanların ve dönüş tipinin orijinal fonksiyonun argümanları ve dönüş tipiyle eşleşmesini bekler. Bu metod, birden fazla fonksiyon çağrısı için farklı sonuçlar üretmek üzere zincirlenebilir.

const myMockFn = vi
  .fn()
  .mockImplementationOnce(() => true) // 1. çağrı
  .mockImplementationOnce(() => false); // 2. çağrı

myMockFn(); // 1. çağrı: true
myMockFn(); // 2. çağrı: false

Mocklanan fonksiyonun implementasyonları bittiğinde, vi.fn(() => defaultValue) veya .mockImplementation(() => defaultValue) ile ayarlanmış varsayılan implementasyonu çağırı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

function withImplementation(fn: T, cb: () => void): MockInstance<T>;
function withImplementation(
  fn: T,
  cb: () => Promise<void>
): Promise<MockInstance<T>>;

Callback yürütülürken orijinal mock implementasyonunu geçici olarak geçersiz kılar.

const myMockFn = vi.fn(() => 'original');

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

myMockFn(); // 'original'

Asenkron bir callback ile kullanılabilir. Metodun, daha sonra orijinal implementasyonu kullanmak için beklenmesi gerekir.

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

  // Callback asenkron olduğu için bu çağrıyı bekliyoruz
  await myMockFn.withImplementation(
    () => 'temp',
    async () => {
      myMockFn(); // 'temp'
    }
  );

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

Bu metodun mockImplementationOnce üzerinde önceliği olduğunu unutmayın.

mockRejectedValue

function mockRejectedValue(value: unknown): MockInstance<T>;

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

const asyncMock = vi.fn().mockRejectedValue(new Error('Async error'));

await asyncMock(); // Error('Async error') fırlatır

mockRejectedValueOnce

function mockRejectedValueOnce(value: unknown): MockInstance<T>;

Bir sonraki fonksiyon çağrısı sırasında reddedilecek bir değeri kabul eder. Zincirlenirse, her ardışık çağrı belirtilen değeri reddeder.

const asyncMock = vi
  .fn()
  .mockResolvedValueOnce('first call')
  .mockRejectedValueOnce(new Error('Async error'));

await asyncMock(); // 'first call'
await asyncMock(); // Error('Async error') fırlatır

mockReset

function mockReset(): MockInstance<T>;

mockClear ile aynı eylemleri gerçekleştirir ve iç implementasyonu boş bir fonksiyona (çağrıldığında undefined döndüren) ayarlar. Bu ayrıca tüm "once" implementasyonlarını da sıfırlar. Bir mock'u tamamen varsayılan durumuna sıfırlamak için kullanışlıdır.

Bu metodu her testten önce otomatik olarak çağırmak için, konfigürasyondaki mockReset ayarını etkinleştirin.

mockRestore

function mockRestore(): MockInstance<T>;

mockReset ile aynı eylemleri gerçekleştirir ve iç implementasyonu orijinal fonksiyona geri yükler.

vi.fn() ile oluşturulan bir mock'u geri yüklemenin, implementasyonu undefined döndüren boş bir fonksiyona ayarlayacağını unutmayın. vi.fn(impl) ile oluşturulan bir mock'u geri yüklemek, implementasyonu impl'e geri yükler.

Bu metodu her testten önce otomatik olarak çağırmak için, konfigürasyondaki restoreMocks ayarını etkinleştirin.

mockResolvedValue

function mockResolvedValue(value: Awaited<ReturnType<T>>): MockInstance<T>;

Asenkron fonksiyon çağrıldığında çözümlenecek bir değeri kabul eder. TypeScript yalnızca orijinal fonksiyonun dönüş tipiyle eşleşen değerleri kabul eder.

const asyncMock = vi.fn().mockResolvedValue(42);

await asyncMock(); // 42

mockResolvedValueOnce

function mockResolvedValueOnce(value: Awaited<ReturnType<T>>): MockInstance<T>;

Bir sonraki fonksiyon çağrısı sırasında çözümlenecek bir değeri kabul eder. TypeScript yalnızca orijinal fonksiyonun dönüş tipiyle eşleşen değerleri kabul eder. Zincirlenirse, her ardışık çağrı belirtilen değeri çözümler.

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

function mockReturnThis(): MockInstance<T>;

Gerçek implementasyonu çağırmadan metoddan this bağlamını döndürmeniz gerekiyorsa bunu kullanın. Bu, aşağıdakinin kısaltmasıdır:

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

mockReturnValue

function mockReturnValue(value: ReturnType<T>): MockInstance<T>;

Mock fonksiyonu her çağrıldığında döndürülecek bir değeri kabul eder. TypeScript yalnızca orijinal fonksiyonun dönüş tipiyle eşleşen değerleri kabul eder.

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

mockReturnValueOnce

function mockReturnValueOnce(value: ReturnType<T>): MockInstance<T>;

Mock fonksiyonu her çağrıldığında döndürülecek bir değeri kabul eder. TypeScript yalnızca orijinal fonksiyonun dönüş tipiyle eşleşen değerleri kabul eder.

Mocklanan fonksiyonun implementasyonları bittiğinde, vi.fn(() => defaultValue) veya .mockImplementation(() => defaultValue) ile ayarlanmış varsayılan implementasyonu çağırı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

const calls: Parameters<T>[];

Bu, her çağrı için tüm argümanları içeren bir dizidir. Dizinin bir öğesi, o çağrının argümanlarıdır.

const fn = vi.fn();

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

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

mock.lastCall

const lastCall: Parameters<T> | undefined;

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

mock.results

interface MockResultReturn<T> {
  type: 'return';
  /**
   * Fonksiyondan döndürülen değer.
   * Eğer fonksiyon bir Promise döndürdüyse, bu çözümlenmiş bir değer olacaktır.
   */
  value: T;
}

interface MockResultIncomplete {
  type: 'incomplete';
  value: undefined;
}

interface MockResultThrow {
  type: 'throw';
  /**
   * Fonksiyon çalıştırılırken fırlatılan bir hata.
   */
  value: any;
}

type MockResult<T> =
  | MockResultReturn<T>
  | MockResultThrow
  | MockResultIncomplete;

const results: MockResult<ReturnType<T>>[];

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

• 'return' - fonksiyon hata fırlatmadan 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. Eğer fonksiyon bir Promise döndürdüyse, promise reddedilmiş olsa bile result her zaman 'return' olur.

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

const result = fn(); // 'result' döndürdü

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

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

mock.settledResults

interface MockSettledResultFulfilled<T> {
  type: 'fulfilled';
  value: T;
}

interface MockSettledResultRejected {
  type: 'rejected';
  value: any;
}

export type MockSettledResult<T> =
  | MockSettledResultFulfilled<T>
  | MockSettledResultRejected;

const settledResults: MockSettledResult<Awaited<ReturnType<T>>>[];

Fonksiyondan çözümlenen veya reddedilen tüm değerleri içeren bir dizi.

Fonksiyon hiçbir zaman çözümlenmediyse veya reddedilmediyse bu dizi boş olacaktır.

const fn = vi.fn().mockResolvedValueOnce('result');

const result = fn();

fn.mock.settledResults === [];

await result;

fn.mock.settledResults ===
  [
    {
      type: 'fulfilled',
      value: 'result',
    },
  ];

mock.invocationCallOrder

const invocationCallOrder: number[];

Bu özellik, mock fonksiyonunun yürütülme sırasını döndürür. Tanımlanmış tüm mock'lar arasında paylaşılan bir sayı dizisidir.

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

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

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

mock.contexts

const contexts: ThisParameterType<T>[];

Bu özellik, mock fonksiyonuna yapılan her çağrı sırasında kullanılan this değerlerinin bir dizisidir.

const fn = vi.fn();
const context = {};

fn.apply(context);
fn.call(context);

fn.mock.contexts[0] === context;
fn.mock.contexts[1] === context;

mock.instances

const instances: ReturnType<T>[];

Bu özellik, mock new anahtar kelimesiyle çağrıldığında oluşturulan tüm örnekleri içeren bir dizidir. Bunun, fonksiyonun gerçek bağlamı (this) olduğunu, dönüş değeri olmadığını unutmayın.

WARNING

Eğer mock new MyClass() ile örneklendirilirse, mock.instances bir değere sahip bir dizi olur:

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

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

Eğer yapılandırıcıdan bir değer döndürürseniz, bu instances dizisinde olmayacak, bunun yerine results içinde olur:

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

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