Sahte Fonksiyonlar

vi.fn metodu ile çalışmasını izlemek için bir sahte fonksiyon oluşturabilirsiniz. Eğer zaten oluşturulmuş bir nesne üzerindeki bir metodu izlemek 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;

Sahte sonuçları doğrulamak için expect üzerinde sahte fonksiyon iddialarını (örneğin, toHaveBeenCalled) kullanmalısınız. Bu API referansı, sahte davranışı değiştirmek için mevcut özellikleri ve metotları açıklamaktadır.

getMockImplementation

• Tip: (...args: any) => any

Eğer tanımlanmışsa, mevcut sahte uygulamayı döndürür.

Sahte vi.fn ile oluşturulduysa, sağlanan metodu bir sahte uygulama olarak kabul eder.

Sahte vi.spyOn ile oluşturulduysa ve özel bir uygulama belirtilmediyse undefined döndürür.

getMockName

• Tip: () => string

.mockName(name) metodu ile sahte fonksiyona atanan adı döndürmek için kullanılır.

mockClear

• Tip: () => MockInstance

Her çağrı ile ilgili tüm bilgileri temizler. Çağrıldıktan sonra, .mock üzerindeki tüm özellikler boş bir durum döndürür. Bu metot uygulamaları sıfırlamaz. Farklı doğrulamalar arasında sahte fonksiyonu temizlemeniz gerektiğinde kullanışlıdır.

Bu metodu her testten önce otomatik olarak çağırmak istiyorsanız, yapılandırmada clearMocks ayarını etkinleştirebilirsiniz.

mockName

• Tip: (name: string) => MockInstance

Sahte fonksiyona bir isim atar. Doğrulama başarısız olursa sahte fonksiyonun adını görmek için kullanışlıdır.

mockImplementation

• Tip: (fn: Function) => MockInstance

Sahte fonksiyonun nasıl davranacağını belirleyen bir fonksiyonu kabul eder.

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

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

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

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

Sahte fonksiyonun uygulamaları bittiğinde, vi.fn(() => defaultValue) veya .mockImplementation(() => defaultValue) ile ayarlanan varsayılan uygulamayı çağırır:

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

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

Geri çağırma (callback) çalışırken orijinal sahte uygulamayı geçici olarak geçersiz kılar.

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

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

myMockFn(); // 'original'

Asenkron bir geri çağırma ile kullanılabilir. Orijinal uygulamayı kullanmaya devam etmek için metodun tamamlanması beklenmelidir.

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

  // Geri çağırma asenkron olduğundan, bu çağrının tamamlanmasını bekliyoruz
  await myMockFn.withImplementation(
    () => 'temp',
    async () => {
      myMockFn(); // 'temp'
    }
  );

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

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

mockRejectedValue

• Tip: (value: any) => MockInstance

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

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

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

mockRejectedValueOnce

• Tip: (value: any) => MockInstance

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.

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

• Tip: () => MockInstance

mockClear'ın yaptığını yapar ve iç uygulamayı boş bir fonksiyon haline getirir (undefined döndürür). Bu aynı zamanda tüm "once" uygulamalarını da sıfırlar. Bu, bir sahte fonksiyonu tamamen varsayılan durumuna sıfırlamak istediğinizde kullanışlıdır.

Bu metodu her testten önce otomatik olarak çağırmak istiyorsanız, yapılandırmada mockReset ayarını etkinleştirebilirsiniz.

mockRestore

• Tip: () => MockInstance

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

vi.fn()'den sahte fonksiyonu geri yüklemenin, uygulamayı undefined döndüren boş bir fonksiyona ayarlayacağını unutmayın. vi.fn(impl)'i geri yüklemek, uygulamayı impl'e geri yükleyecektir.

Bu metodu her testten önce otomatik olarak çağırmak istiyorsanız, yapılandırmada restoreMocks ayarını etkinleştirebilirsiniz.

mockResolvedValue

• Tip: (value: any) => MockInstance

Asenkron fonksiyon çağrıldığında yerine getirilecek bir değeri kabul eder.

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

await asyncMock(); // 42

mockResolvedValueOnce

• Tip: (value: any) => MockInstance

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

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

• Tip: () => MockInstance

Gerçek uygulamayı çağırmadan metottan this bağlamını döndürmeniz gerekiyorsa bunu kullanın. Bu, aşağıdakiler için bir kısayoldur:

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

mockReturnValue

• Tip: (value: any) => MockInstance

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

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

mockReturnValueOnce

• Tip: (value: any) => MockInstance

Bir sonraki fonksiyon çağrısı sırasında döndürülecek bir değeri kabul eder. Zincirlenirse, her ardışık çağrı belirtilen değeri döndürür.

Kullanılacak daha fazla mockReturnValueOnce değeri kalmadığında, sahte fonksiyon varsa önceden tanımlanmış uygulamaya geri döner.

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

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

const fn = vi.fn();

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

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

mock.lastCall

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

mock.results

Bu, fonksiyondan returned edilen tüm değerleri içeren bir dizidir. Dizinin her bir öğesi, type ve value özelliklerine sahip bir nesnedir. Mevcut türler şunlardır:

• 'return' - fonksiyon hata vermeden 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, value, çözülmemişse gerçek Promise değil, çözümlenmiş değer olacaktır.

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

Sahte fonksiyonun yürütülme sırası. Bu, tanımlanan tüm sahte fonksiyonlar arasında paylaşılan bir sayı dizisi döndürür.

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

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

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

mock.instances

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

WARNING

Sahte fonksiyon 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;

Eğer yapıcı bir değer döndürürse, bu değer instances dizisinde değil, results dizisinde yer alır.

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

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