Mock Fonksiyonlar

vi.fn metodu ile bir mock fonksiyonu oluşturarak yürütülmesini takip edebilirsiniz. Zaten oluşturulmuş bir nesne üzerindeki bir metodu takip etmek isterseniz, 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 sonucunu doğrulamak için expect üzerinde mock doğrulayıcıları (örneğin, toHaveBeenCalled) kullanmalısınız. Bu API referansı, mock davranışını manipüle etmek için mevcut özellikleri ve yöntemleri açıklar.

TIP

Aşağıdaki tiplerdeki özel fonksiyon uygulaması <T> jeneriği ile işaretlenmiştir.

getMockImplementation

function getMockImplementation(): T | undefined;

Varsa, mevcut mock uygulamasını döndürür.

Mock vi.fn ile oluşturulduysa, sağlanan metodu mock uygulama olarak kullanacaktır.

Mock vi.spyOn ile oluşturulduysa, özel bir uygulama sağlanmadıkça undefined döndürecektir.

getMockName

function getMockName(): string;

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

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önecektir. Bu yöntem mock uygulamalarını sıfırlamaz. Farklı test senaryoları arasında mock'ları temizlemek için kullanışlıdır.

const person = {
  greet: (name: string) => `Hello ${name}`,
};
const spy = vi.spyOn(person, 'greet').mockImplementation(() => 'mocked');
expect(person.greet('Alice')).toBe('mocked');
expect(spy.mock.calls).toEqual([['Alice']]);

// çağrı geçmişini temizle ama mock uygulamayı koru
spy.mockClear();
expect(spy.mock.calls).toEqual([]);
expect(person.greet('Bob')).toBe('mocked');
expect(spy.mock.calls).toEqual([['Bob']]);

Bu metodu her testten önce otomatik olarak çağırmak için, yapılandırmadaki 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 uygulama olarak kullanılacak bir fonksiyonu kabul eder. TypeScript, argümanların ve dönüş tipinin orijinal fonksiyonunkilerle 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 uygulama olarak kullanılacak bir fonksiyonu kabul eder. TypeScript, argümanların ve dönüş tipinin orijinal fonksiyonunkilerle 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

Mock fonksiyonun tanımlı uygulamaları tükendiğinde, vi.fn(() => defaultValue) veya .mockImplementation(() => defaultValue) ile ayarlanmış 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

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 uygulamasını 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 uygulamayı 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ğe sahip 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'> hatası 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 reddedecektir.

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

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

mockReset

function mockReset(): MockInstance<T>;

mockClear ne yapıyorsa onu yapar ve iç uygulamayı orijinal fonksiyona sıfırlar. Bu aynı zamanda tüm tek seferlik uygulamaları da sıfırlar.

vi.fn() ile oluşturulmuş bir mock'u sıfırlamanın, uygulamasını undefined döndüren boş bir fonksiyona ayarlayacağını unutmayın. vi.fn(impl) ile oluşturulmuş bir mock'u sıfırlamak, uygulamasını impl'ye geri yükleyecektir.

Bu, bir mock'u orijinal durumuna sıfırlamak istediğinizde kullanışlıdır.

const person = {
  greet: (name: string) => `Hello ${name}`,
};
const spy = vi.spyOn(person, 'greet').mockImplementation(() => 'mocked');
expect(person.greet('Alice')).toBe('mocked');
expect(spy.mock.calls).toEqual([['Alice']]);

// çağrı geçmişini temizle ve uygulamayı sıfırla, ancak metod hala spy'lanıyor
spy.mockReset();
expect(spy.mock.calls).toEqual([]);
expect(person.greet).toBe(spy);
expect(person.greet('Bob')).toBe('Hello Bob');
expect(spy.mock.calls).toEqual([['Bob']]);

Bu metodu her testten önce otomatik olarak çağırmak için, yapılandırmadaki mockReset ayarını etkinleştirin.

mockRestore

function mockRestore(): MockInstance<T>;

mockReset ne yapıyorsa onu yapar ve spy'lanmış nesnelerin orijinal tanımlayıcılarını geri yükler.

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

const person = {
  greet: (name: string) => `Hello ${name}`,
};
const spy = vi.spyOn(person, 'greet').mockImplementation(() => 'mocked');
expect(person.greet('Alice')).toBe('mocked');
expect(spy.mock.calls).toEqual([['Alice']]);

// çağrı geçmişini temizle ve spy'lanmış nesne metodunu geri yükle
spy.mockRestore();
expect(spy.mock.calls).toEqual([]);
expect(person.greet).not.toBe(spy);
expect(person.greet('Bob')).toBe('Hello Bob');
expect(spy.mock.calls).toEqual([]);

Bu metodu her testten önce otomatik olarak çağırmak için, yapılandırmadaki 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 edecektir.

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 edecektir. Zincirlenirse, her ardışık çağrı belirtilen değeri çözecektir.

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 uygulamayı çağırmadan metoddan this bağlamını döndürmeniz gerekiyorsa bunu kullanın. Bu, aşağıdaki gibi kısaltılabilir:

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

mockReturnValue

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

Mock fonksiyon 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 edecektir.

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

mockReturnValueOnce

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

Mock fonksiyon 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 edecektir.

Mock fonksiyonun tanımlı uygulamaları tükendiğinde, vi.fn(() => defaultValue) veya .mockImplementation(() => defaultValue) ile ayarlanmış varsayılan uygulamayı çağıracaktı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. Mock çağrılmadıysa, undefined döndürecektir.

mock.results

interface MockResultReturn<T> {
  type: 'return';
  /**
   * Fonksiyondan döndürülen değ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 yürütme sırasında fırlatılan bir hata.
   */
  value: any;
}

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

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

Bu, fonksiyondan dönen 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. Fonksiyon bir Promise döndürdüyse, promise reddedilmiş olsa bile result her zaman 'return' olacaktır.

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

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

try {
  fn(); // Hata 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ç çö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 fonksiyonun yürütme 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 fonksiyona 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

Bir mock new MyClass() ile örneklendirilmişse, mock.instances bir değere sahip bir dizi olacaktır:

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

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

Kurucudan bir değer döndürürseniz, bu instances dizisinde değil, 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;