Vi

Vitest, vi yardımcı fonksiyonu aracılığıyla size yardımcı olacak işlevler sunar. Bu fonksiyonlara global olarak erişebilirsiniz (global yapılandırma etkinleştirildiğinde), veya vitest'ten içe aktarabilirsiniz:

import { vi } from 'vitest';

vi.advanceTimersByTime

Tip: (ms: number) => Vitest
runAllTimers gibi çalışır, ancak belirtilen milisaniye kadar ilerledikten sonra durur. Örneğin, aşağıdaki kod 1, 2, 3 çıktısını verir ve hata oluşmaz:
ts
```
let i = 0;
setInterval(() => console.log(++i), 50);

vi.advanceTimersByTime(150);
```

vi.advanceTimersByTimeAsync

Tip: (ms: number) => Promise<Vitest>
runAllTimersAsync gibi çalışır, ancak belirtilen milisaniye kadar ilerledikten sonra durur. Bu, asenkron olarak ayarlanan zamanlayıcıları da kapsar. Örneğin, aşağıdaki kod 1, 2, 3 çıktısını verir ve hata oluşmaz:
ts
```
let i = 0;
setInterval(() => Promise.resolve().then(() => console.log(++i)), 50);

await vi.advanceTimersByTimeAsync(150);
```

vi.advanceTimersToNextTimer

Tip: () => Vitest
Bir sonraki çalışmaya hazır zamanlayıcıyı tetikler. Her zamanlayıcı tetiklemesi arasında kontroller yapmak için kullanışlıdır. Zamanlayıcıları manuel olarak yönetmek için zincirleme çağrılar yapabilirsiniz.
ts
```
let i = 0;
setInterval(() => console.log(++i), 50);

vi.advanceTimersToNextTimer() // log 1
  .advanceTimersToNextTimer() // log 2
  .advanceTimersToNextTimer(); // log 3
```

vi.advanceTimersToNextTimerAsync

Tip: () => Promise<Vitest>
Asenkron olarak ayarlanmış olsa bile bir sonraki çalışmaya hazır zamanlayıcıyı tetikler. Her zamanlayıcı tetiklemesi arasında kontroller yapmak için kullanışlıdır. Zamanlayıcıları manuel olarak yönetmek için zincirleme çağrılar yapabilirsiniz.
ts
```
let i = 0;
setInterval(() => Promise.resolve().then(() => console.log(++i)), 50);

vi.advanceTimersToNextTimerAsync() // log 1
  .advanceTimersToNextTimerAsync() // log 2
  .advanceTimersToNextTimerAsync(); // log 3
```

vi.getTimerCount

Tip: () => number
Bekleyen zamanlayıcıların sayısını döndürür.

vi.clearAllMocks

Tüm mock fonksiyonlarında .mockClear() fonksiyonunu çağırır. Bu, mock fonksiyonlarının geçmişini temizler, ancak uygulamasını varsayılan haline sıfırlamaz.

vi.clearAllTimers

Çalışması planlanan tüm zamanlayıcıları iptal eder. Bu zamanlayıcılar artık çalıştırılmayacaktır.

vi.dynamicImportSettled

Tüm dinamik içe aktarmaların tamamlanmasını bekler. Aksi takdirde bekleyemeyeceğiniz bir modül içe aktarma işlemi başlatan eşzamanlı bir çağrı varsa kullanışlıdır.

vi.fn

Tip: (fn?: Function) => Mock
Bir fonksiyon üzerinde izleme (spy) oluşturur, ancak bir fonksiyon olmadan da başlatılabilir. Bir fonksiyon her çağrıldığında, çağrı argümanlarını, dönüş değerlerini ve örneklerini saklar. Ayrıca, metotlarla davranışını değiştirebilirsiniz. Fonksiyon verilmezse, sahte fonksiyon çağrıldığında undefined döndürür.
ts
```
const getApples = vi.fn(() => 0);

getApples();

expect(getApples).toHaveBeenCalled();
expect(getApples).toHaveReturnedWith(0);

getApples.mockReturnValueOnce(5);

const res = getApples();
expect(res).toBe(5);
expect(getApples).toHaveNthReturnedWith(2, 5);
```

vi.getMockedSystemTime

Tip: () => Date | null
setSystemTime kullanılarak ayarlanan sahte geçerli tarihi döndürür. Tarih sahte değilse, null döndürür.

vi.getRealSystemTime

Tip: () => number
vi.useFakeTimers kullanırken, Date.now çağrıları sahtedir. Milisaniye cinsinden gerçek zamanı almanız gerekiyorsa, bu fonksiyonu çağırabilirsiniz.

vi.hoisted

Tip: <T>(factory: () => T) => T
Sürüm: Vitest 0.31.0'dan beri
ES modüllerindeki tüm statik import ifadeleri dosyanın en üstüne taşınır, bu nedenle içe aktarmalardan önce tanımlanan herhangi bir kod aslında içe aktarmalar değerlendirildikten sonra yürütülür.
Ancak, bir modülü içe aktarmadan önce tarihleri sahte hale getirmek gibi bazı yan etkileri tetiklemek yararlı olabilir.
Bu sınırlamayı aşmak için, statik içe aktarmaları aşağıdaki gibi dinamik olanlara dönüştürebilirsiniz:
diff
```
callFunctionWithSideEffect()
- import { value } from './some/module.ts'
+ const { value } = await import('./some/module.ts')
```
vitest çalıştırırken, vi.hoisted metodunu kullanarak bunu otomatik olarak yapabilirsiniz.
diff
```
- callFunctionWithSideEffect()
import { value } from './some/module.ts'
+ vi.hoisted(() => callFunctionWithSideEffect())
```
Bu metot, fabrikadan döndürülen değeri döndürür. Yerel olarak tanımlanmış değişkenlere kolay erişime ihtiyacınız varsa, bu değeri vi.mock fabrikalarınızda kullanabilirsiniz:
ts
```
import { expect, vi } from 'vitest';
import { originalMethod } from './path/to/module.js';

const { mockedMethod } = vi.hoisted(() => {
  return { mockedMethod: vi.fn() };
});

vi.mock('./path/to/module.js', () => {
  return { originalMethod: mockedMethod };
});

mockedMethod.mockReturnValue(100);
expect(originalMethod()).toBe(100);
```

vi.mock

Tip: (path: string, factory?: () => unknown) => void
Belirtilen path'ten içe aktarılan tüm modüllerin yerine başka bir modül koyar. Bir yol içinde yapılandırılmış Vite takma adlarını kullanabilirsiniz. vi.mock çağrısı yukarı taşınır, bu nedenle onu nerede çağırdığınızın bir önemi yoktur. Her zaman tüm içe aktarmalardan önce yürütülecektir. Kapsamı dışındaki bazı değişkenlere erişmeniz gerekiyorsa, bu değişkenleri vi.hoisted içinde tanımlayıp vi.mock içinde kullanabilirsiniz.
WARNING
vi.mock yalnızca import anahtar kelimesiyle içe aktarılan modüller için çalışır. require ile çalışmaz.
Vitest, vi.mock'u yukarı taşımak için dosyalarınızı statik olarak analiz eder. Bu, doğrudan vitest paketinden içe aktarılmayan vi'yi (örneğin, bazı yardımcı dosyalardan) kullanamayacağınız anlamına gelir. Bunu düzeltmek için, her zaman vitest'ten içe aktarılan vi ile vi.mock kullanın veya globals yapılandırma seçeneğini etkinleştirin.
WARNING
Modülleri mocklama şu anda tarayıcı modunda desteklenmemektedir. Bu özelliği GitHub sorununda takip edebilirsiniz.
factory tanımlanmışsa, tüm içe aktarmalar sonucunu döndürür. Vitest, fabrika işlevini yalnızca bir kez çalıştırır ve vi.unmock veya vi.doUnmock fonksiyonları çağrılana kadar sonraki tüm içe aktarmalar için sonucu saklar.
jest'ten farklı olarak, factory asenkron olabilir, bu nedenle orijinal modülü almak için vi.importActual veya ilk argüman olarak alınan bir yardımcıyı kullanabilirsiniz.
ts
```
vi.mock('./path/to/module.js', async importOriginal => {
  const mod = await importOriginal();
  return {
    ...mod,
    // bazı dışa aktarmaları değiştir
    namedExport: vi.fn(),
  };
});
```
WARNING
vi.mock yukarı taşınır ve dosyanın en üstünde yer alır. Bu, onu ne zaman yazarsanız yazın (ister beforeEach içinde ister test içinde olsun), aslında bundan önce çağrılacağı anlamına gelir.
Bu durum, factory fonksiyonunun dışında tanımlanan değişkenleri factory fonksiyonunun içinde kullanamayacağınız anlamına gelir.
Factory içinde değişkenler kullanmanız gerekiyorsa, vi.doMock'u deneyin. Aynı şekilde çalışır, ancak yukarı taşınmaz. Yalnızca sonraki içe aktarmaları sahte hale getirdiğine dikkat edin.
Ayrıca, vi.mock'tan önce tanımlanmışsa, vi.hoisted metodu tarafından tanımlanan değişkenlere de başvurabilirsiniz:
ts
```
import { namedExport } from './path/to/module.js';

const mocks = vi.hoisted(() => {
  return {
    namedExport: vi.fn(),
  };
});

vi.mock('./path/to/module.js', () => {
  return {
    namedExport: mocks.namedExport,
  };
});

vi.mocked(namedExport).mockReturnValue(100);

expect(namedExport()).toBe(100);
expect(namedExport).toBe(mocks.namedExport);
```
WARNING
Varsayılan dışa aktarmaya sahip bir modülü sahte hale getiriyorsanız, döndürülen factory fonksiyon nesnesi içinde bir default anahtarı sağlamanız gerekir. Bu, bir ES modüllerine özgü bir durumdur, bu nedenle jest belgeleri farklılık gösterebilir, çünkü jest CommonJS modüllerini kullanır. Örneğin,
ts
```
vi.mock('./path/to/module.js', () => {
  return {
    default: { myDefaultKey: vi.fn() },
    namedExport: vi.fn(),
    // vb...
  };
});
```
Mockladığınız bir dosyanın yanında bir __mocks__ klasörü varsa ve factory sağlanmamışsa, Vitest __mocks__ alt klasöründe aynı ada sahip bir dosya bulmaya çalışacak ve bunu gerçek bir modül olarak kullanacaktır. Bir bağımlılığı sahte hale getiriyorsanız, Vitest projenin kökünde bir __mocks__ klasörü bulmaya çalışacaktır (varsayılan process.cwd()'dir). deps.moduleDirectories yapılandırma seçeneği aracılığıyla Vitest'e bağımlılıkların nerede bulunduğunu söyleyebilirsiniz.
Örneğin, şu dosya yapısına sahipsiniz:
```
- __mocks__
  - axios.js
- src
  __mocks__
    - increment.js
  - increment.js
- tests
  - increment.test.js
```
Bir test dosyasında bir factory sağlanmadan vi.mock çağırırsanız, bir modül olarak kullanılacak __mocks__ klasöründe bir dosya bulacaktır:
ts
```
// increment.test.js
import { vi } from 'vitest';

// axios, `__mocks__/axios.js`'den varsayılan bir dışa aktarımdır
import axios from 'axios';

// increment, `src/__mocks__/increment.js`'den adlandırılmış bir dışa aktarımdır
import { increment } from '../increment.js';

vi.mock('axios');
vi.mock('../increment.js');

axios.get(`/apples/${increment(1)}`);
```
WARNING
vi.mock'u çağırmazsanız, modüller otomatik olarak mocklanmaz. Jest'in otomatik mocklama davranışını elde etmek için, setupFiles içinde gerekli her modül için vi.mock çağırabilirsiniz.
__mocks__ klasörü veya sağlanan bir factory yoksa, Vitest orijinal modülü içe aktaracak ve tüm dışa aktarımlarını otomatik olarak sahte hale getirecektir. Uygulanan kurallar için algoritma'ya bakın.

vi.doMock

Tip: (path: string, factory?: () => unknown) => void
vi.mock ile aynıdır, ancak dosyanın en üstüne taşınmadığı için global kapsamdaki değişkenlere erişebilirsiniz. Modülün bir sonraki dinamik içe aktarımı sahte hale getirilecektir. Bu, bundan önce içe aktarılan modülleri sahte hale getirmeyecektir.

// ./increment.js
export function increment(number) {
  return number + 1;
}

import { beforeEach, test } from 'vitest';
import { increment } from './increment.js';

// modül sahte değil, çünkü vi.doMock henüz çağrılmadı
increment(1) === 2;

let mockedIncrement = 100;

beforeEach(() => {
  // bir factory içindeki değişkenlere erişebilirsiniz
  vi.doMock('./increment.js', () => ({ increment: () => ++mockedIncrement }));
});

test('bir sonraki modülü içe aktarmak sahte olanı içe aktarır', async () => {
  // orijinal içe aktarma SAHTE DEĞİLDİ, çünkü vi.doMock içe aktarmalardan SONRA değerlendirilir
  expect(increment(1)).toBe(2);
  const { increment: mockedIncrement } = await import('./increment.js');
  // yeni dinamik içe aktarma sahte modülü döndürür
  expect(mockedIncrement(1)).toBe(101);
  expect(mockedIncrement(1)).toBe(102);
  expect(mockedIncrement(1)).toBe(103);
});

vi.mocked

Tip: <T>(obj: T, deep?: boolean) => MaybeMockedDeep<T>

Tip: <T>(obj: T, options?: { partial?: boolean; deep?: boolean }) => MaybePartiallyMockedDeep<T>

TypeScript için tip yardımcısıdır. Gerçekte sadece geçirilen nesneyi döndürür.

partial true olduğunda, bir Partial<T> bekleyecektir.

import example from './example.js';

vi.mock('./example.js');

test('1+1 eşittir 2', async () => {
  vi.mocked(example.calc).mockRestore();

  const res = example.calc(1, '+', 1);

  expect(res).toBe(2);
});

vi.importActual

Tip: <T>(path: string) => Promise<T>
Mocklanıp mocklanmayacağına dair tüm kontrolleri atlayarak modülü içe aktarır. Modülü kısmen sahte hale getirmek istiyorsanız yararlı olabilir.
ts
```
vi.mock('./example.js', async () => {
  const axios = await vi.importActual('./example.js');

  return { ...axios, get: vi.fn() };
});
```

vi.importMock

Tip: <T>(path: string) => Promise<MaybeMockedDeep<T>>
Tüm özellikleri (iç içe geçmiş özellikler dahil) mocklanmış bir modülü içe aktarır. vi.mock'un izlediği aynı kuralları izler. Uygulanan kurallar için algoritma'ya bakın.

vi.resetAllMocks

Tüm mock fonksiyonlarında .mockReset()'i çağırır. Bu, mock fonksiyon geçmişini temizler ve uygulamasını boş bir fonksiyona sıfırlar (undefined döndürür).

vi.resetConfig

Tip: RuntimeConfig
Daha önce vi.setConfig çağrıldıysa, bu yapılandırmayı orijinal durumuna sıfırlayacaktır.

vi.resetModules

Tip: () => Vitest

Tüm modüllerin önbelleğini temizleyerek modüller kayıt defterini sıfırlar. Bu, modüllerin yeniden içe aktarıldığında değerlendirilmesini sağlar. En üst düzey içe aktarmalar yeniden değerlendirilemez. Yerel durumun testler arasında çakışma yarattığı modülleri izole etmek için yararlı olabilir.

import { vi } from 'vitest';

import { data } from './data.js'; // Her testten önce yeniden değerlendirilmeyecek

beforeEach(() => {
  vi.resetModules();
});

test('durumu değiştir', async () => {
  const mod = await import('./some/path.js'); // Yeniden değerlendirilecek
  mod.changeLocalState('new value');
  expect(mod.getLocalState()).toBe('new value');
});

test('modülün eski durumu var', async () => {
  const mod = await import('./some/path.js'); // Yeniden değerlendirilecek
  expect(mod.getLocalState()).toBe('old value');
});

WARNING

Mock fonksiyonlar kayıt defterini temizlemez. Mock fonksiyonlar kayıt defterini temizlemek için vi.unmock veya vi.doUnmock kullanın.

vi.restoreAllMocks

Tüm mock fonksiyonlarında .mockRestore()'u çağırır. Bu, mock fonksiyon geçmişini temizler ve uygulamasını orijinal olana sıfırlar.

vi.stubEnv

Tip: (name: string, value: string) => Vitest
Sürüm: Vitest 0.26.0'dan beri
process.env ve import.meta.env'deki ortam değişkenlerinin değerini değiştirir. vi.unstubAllEnvs'i çağırarak değerini geri yükleyebilirsiniz.

import { vi } from 'vitest';

// `process.env.NODE_ENV` ve `import.meta.env.NODE_ENV`
// "vi.stubEnv" çağrılmadan önce "development"dır

vi.stubEnv('NODE_ENV', 'production');

process.env.NODE_ENV === 'production';
import.meta.env.NODE_ENV === 'production';
// diğer ortamları değiştirmez
import.meta.env.MODE === 'development';

TIP

Değeri basitçe atayarak da değiştirebilirsiniz, ancak önceki değeri geri yüklemek için vi.unstubAllEnvs'i kullanamazsınız:

import.meta.env.MODE = 'test';

vi.unstubAllEnvs

Tip: () => Vitest
Sürüm: Vitest 0.26.0'dan beri
vi.stubEnv ile değiştirilen tüm import.meta.env ve process.env değerlerini orijinal hallerine geri döndürür. Vitest, stubEnv ilk kez çağrıldığında orijinal değeri kaydeder ve unstubAllEnvs tekrar çağrılana kadar bu değeri saklar.

import { vi } from 'vitest';

// `process.env.NODE_ENV` ve `import.meta.env.NODE_ENV`
// stubEnv çağrılmadan önce "development" değerindedir

vi.stubEnv('NODE_ENV', 'production');

process.env.NODE_ENV === 'production';
import.meta.env.NODE_ENV === 'production';

vi.stubEnv('NODE_ENV', 'staging');

process.env.NODE_ENV === 'staging';
import.meta.env.NODE_ENV === 'staging';

vi.unstubAllEnvs();

// İlk "stubEnv" çağrısından önce kaydedilen değere geri döner
process.env.NODE_ENV === 'development';
import.meta.env.NODE_ENV === 'development';

vi.stubGlobal

Tip: (name: string | number | symbol, value: unknown) => Vitest
Bu fonksiyon, global bir değişkenin değerini geçici olarak değiştirir. Orijinal değerini geri yüklemek için vi.unstubAllGlobals fonksiyonunu kullanabilirsiniz.

import { vi } from 'vitest';

// `innerWidth`, stubGlobal çağrılmadan önce "0" değerindedir

vi.stubGlobal('innerWidth', 100);

innerWidth === 100;
globalThis.innerWidth === 100;
// jsdom veya happy-dom kullanıyorsanız
window.innerWidth === 100;

TIP

Değeri doğrudan globalThis veya window'a (eğer jsdom veya happy-dom ortamı kullanıyorsanız) atayarak da değiştirebilirsiniz, ancak bu durumda orijinal değeri geri yüklemek için vi.unstubAllGlobals'ı kullanamazsınız:

globalThis.innerWidth = 100;
// jsdom veya happy-dom kullanıyorsanız
window.innerWidth = 100;

vi.unstubAllGlobals

Tip: () => Vitest
Sürüm: Vitest 0.26.0'dan beri
vi.stubGlobal ile değiştirilen globalThis/global (ve window/top/self/parent, eğer jsdom veya happy-dom ortamı kullanıyorsanız) üzerindeki tüm global değerleri orijinal hallerine geri döndürür. Vitest, stubGlobal ilk kez çağrıldığında orijinal değeri kaydeder ve unstubAllGlobals tekrar çağrılana kadar bu değeri saklar.

import { vi } from 'vitest';

const Mock = vi.fn();

// IntersectionObserver, "stubGlobal" çağrılmadan önce "undefined" değerindedir

vi.stubGlobal('IntersectionObserver', Mock);

IntersectionObserver === Mock;
global.IntersectionObserver === Mock;
globalThis.IntersectionObserver === Mock;
// jsdom veya happy-dom kullanıyorsanız
window.IntersectionObserver === Mock;

vi.unstubAllGlobals();

globalThis.IntersectionObserver === undefined;
'IntersectionObserver' in globalThis === false;
// ReferenceError hatası verir, çünkü tanımlı değil
IntersectionObserver === undefined;

vi.runAllTicks

Tip: () => Vitest
process.nextTick tarafından sıraya alınan tüm mikro görevleri çalıştırır. Bu, kendi kendileri tarafından planlanan tüm mikro görevleri de çalıştırır.

vi.runAllTimers

Tip: () => Vitest
Bu metot, zamanlayıcı kuyruğu boşalana kadar başlatılmış olan tüm zamanlayıcıları çalıştırır. Bu, vi.runAllTimers metodu çağrıldığında başlatılan tüm zamanlayıcıların çalıştırılacağı anlamına gelir. Sonsuz bir aralığınız varsa, 10.000 tekrardan sonra bir hata fırlatılır. Örneğin, aşağıdaki kod 1, 2, 3 çıktısını verir:
ts
```
let i = 0;
setTimeout(() => console.log(++i));
const interval = setInterval(() => {
  console.log(++i);
  if (i === 3) clearInterval(interval);
}, 50);

vi.runAllTimers();
```

vi.runAllTimersAsync

Tip: () => Promise<Vitest>
Bu metot, zamanlayıcı kuyruğu boşalana kadar başlatılmış olan tüm zamanlayıcıları asenkron olarak çalıştırır. Bu, vi.runAllTimersAsync metodu çağrıldığında başlatılan tüm zamanlayıcıların (asenkron olanlar dahil) çalıştırılacağı anlamına gelir. Sonsuz bir aralığınız varsa, 10.000 tekrardan sonra bir hata fırlatılır. Örneğin, aşağıdaki kod result çıktısını verir:
ts
```
setTimeout(async () => {
  console.log(await Promise.resolve('result'));
}, 100);

await vi.runAllTimersAsync();
```

vi.runOnlyPendingTimers

Tip: () => Vitest
Bu metot, vi.useFakeTimers() fonksiyonu çağrıldıktan sonra başlatılan ve henüz çalıştırılmamış olan tüm zamanlayıcıları çalıştırır. Bu metot çalışırken başlatılan zamanlayıcılar tetiklenmeyecektir. Örneğin, aşağıdaki kod yalnızca 1 çıktısını verir:
ts
```
let i = 0;
setInterval(() => console.log(++i), 50);

vi.runOnlyPendingTimers();
```

vi.runOnlyPendingTimersAsync

Tip: () => Promise<Vitest>
Bu metot, vi.useFakeTimers() fonksiyonu çağrıldıktan sonra başlatılan ve henüz çalıştırılmamış olan tüm zamanlayıcıları (asenkron olanlar dahil) asenkron olarak çalıştırır. Bu metot çalışırken başlatılan zamanlayıcılar tetiklenmeyecektir. Örneğin, aşağıdaki kod 2, 3, 3, 1 çıktısını verir:
ts
```
setTimeout(() => {
  console.log(1);
}, 100);
setTimeout(() => {
  Promise.resolve().then(() => {
    console.log(2);
    setInterval(() => {
      console.log(3);
    }, 40);
  });
}, 10);

await vi.runOnlyPendingTimersAsync();
```

vi.setSystemTime

Tip: (date: string | number | Date) => void
Sistemin geçerli tarihini, parametre olarak verilen tarihe ayarlar. Bu ayardan sonra tüm Date çağrıları bu tarihi döndürecektir.
Örneğin, kodunuzda luxon gibi geçerli tarihe bağlı olan herhangi bir şeyi test etmeniz gerekiyorsa kullanışlıdır.
ts
```
const date = new Date(1998, 11, 19);

vi.useFakeTimers();
vi.setSystemTime(date);

expect(Date.now()).toBe(date.valueOf());

vi.useRealTimers();
```

vi.setConfig

Tip: RuntimeConfig
Geçerli test dosyası için yapılandırmayı günceller. Yalnızca testleri yürütürken kullanılan değerleri etkileyebilirsiniz.

vi.spyOn

Tip: <T, K extends keyof T>(object: T, method: K, accessType?: 'get' | 'set') => MockInstance

Bir nesnenin bir metodunda veya getter/setter'ında bir izleyici (spy) oluşturur.

let apples = 0;
const cart = {
  getApples: () => 13,
};

const spy = vi.spyOn(cart, 'getApples').mockImplementation(() => apples);
apples = 1;

expect(cart.getApples()).toBe(1);

expect(spy).toHaveBeenCalled();
expect(spy).toHaveReturnedWith(1);

vi.stubGlobal

Tip: (key: keyof globalThis & Window, value: any) => Vitest
Global bir değişkene bir değer atar. jsdom veya happy-dom kullanıyorsanız, değeri window nesnesine de atar.
"Global'leri Mocklama" bölümünde daha fazla bilgi edinin.

vi.unmock

Tip: (path: string) => void
Modülü, taklit edilen modüllerin kayıt defterinden kaldırır. Bu işlemden sonra yapılan tüm import çağrıları, daha önce taklit edilmiş olsa bile orijinal modülü döndürecektir. Bu fonksiyon çağrısı dosyanın en üstüne taşınır (hoisted), bu nedenle yalnızca setupFiles içerisinde tanımlanmış olan modüllerin mock'larını kaldırır.

vi.doUnmock

Tip: (path: string) => void
vi.unmock ile aynıdır, ancak dosyanın en üstüne taşınmaz. Bu fonksiyon çağrıldıktan sonra yapılacak bir sonraki import işlemi, mock'lanmış modül yerine orijinal modülü import edecektir. Bu, daha önce içe aktarılmış olan modüllerin taklidini kaldırmaz.

// ./increment.js
export function increment(number) {
  return number + 1;
}

import { increment } from './increment.js';

// increment zaten mock'lanmış, çünkü vi.mock hoist edilmiştir
increment(1) === 100;

// bu taşınır ve 1. satırdaki içe aktarmadan önce fabrika çağrılır
vi.mock('./increment.js', () => ({ increment: () => 100 }));

// tüm çağrılar taklit edilir ve `increment` her zaman 100 döndürür
increment(1) === 100;
increment(30) === 100;

// bu taşınmaz, bu nedenle diğer içe aktarma taklit edilmemiş modülü döndürecektir
vi.doUnmock('./increment.js');

// bu HALA 100 döndürür, çünkü `vi.doUnmock` bir modülü yeniden değerlendirmez
increment(1) === 100;
increment(30) === 100;

// bir sonraki içe aktarma taklit edilmemiştir, şimdi `increment` sayısı + 1 döndüren orijinal işlevdir
const { increment: unmockedIncrement } = await import('./increment.js');

unmockedIncrement(1) === 2;
unmockedIncrement(30) === 31;

vi.useFakeTimers

Tip: () => Vitest
Zamanlayıcıların mock'lanmasını etkinleştirmek için bu metodu çağırmanız gerekir. vi.useRealTimers() fonksiyonu çağrılana kadar, setTimeout, setInterval, clearTimeout, clearInterval, nextTick, setImmediate, clearImmediate ve Date gibi zamanlayıcı fonksiyonlarına yapılan tüm çağrıları mock'layacaktır.
Vitest, --no-threads kullanılarak node:child_process içinde çalıştırıldığında nextTick'in taklit edilmesi desteklenmez. NodeJS, node:child_process içinde dahili olarak process.nextTick kullanır ve taklit edildiğinde askıda kalır. nextTick'in taklit edilmesi, Vitest --threads ile çalıştırıldığında desteklenir.
Uygulama dahili olarak @sinonjs/fake-timers kütüphanesini temel alır.
TIP
0.35.0 sürümünden beri vi.useFakeTimers() artık process.nextTick'i otomatik olarak taklit etmiyor. toFake argümanında seçeneği belirterek hala taklit edilebilir: vi.useFakeTimers({ toFake: ['nextTick'] }).

vi.isFakeTimers

Tip: () => boolean
Sürüm: Vitest 0.34.5'ten beri
Sahte zamanlayıcılar etkinse true döndürür.

vi.useRealTimers

Tip: () => Vitest
Zamanlayıcılarla işiniz bittiğinde, taklit edilen zamanlayıcıları orijinal uygulamalarına döndürmek için bu yöntemi çağırabilirsiniz. Daha önce çalıştırılan tüm zamanlayıcılar geri yüklenmeyecektir.

vi.waitFor

Tip: <T>(callback: WaitForCallback<T>, options?: number | WaitForOptions) => Promise<T>
Sürüm: Vitest 0.34.5'ten beri

Verilen geri çağırım fonksiyonunun başarılı bir şekilde çalışmasını bekler. Eğer geri çağırım fonksiyonu bir hata fırlatırsa veya reddedilmiş bir Promise dönerse, fonksiyon başarılı olana veya zaman aşımına uğrayana kadar beklemeye devam eder.

Bu, örneğin bir sunucu başlattığınızda ve başlamasını beklemeniz gerektiğinde, bazı asenkron eylemlerin tamamlanmasını beklemeniz gerektiğinde çok kullanışlıdır.

import { expect, test, vi } from 'vitest';
import { createServer } from './server.js';

test('Sunucu başarıyla başlatıldı', async () => {
  const server = createServer();

  await vi.waitFor(
    () => {
      if (!server.isReady) throw new Error('Sunucu başlatılmadı');

      console.log('Sunucu başlatıldı');
    },
    {
      timeout: 500, // varsayılan 1000'dir
      interval: 20, // varsayılan 50'dir
    }
  );
  expect(server.isReady).toBe(true);
});

Asenkron geri çağrılar için de çalışır

// @vitest-environment jsdom

import { expect, test, vi } from 'vitest';
import { getDOMElementAsync, populateDOMAsync } from './dom.js';

test('Bir DOM'da öğe var', async () => {
  // DOM'u doldurmaya başla
  populateDOMAsync();

  const element = await vi.waitFor(
    async () => {
      // var olana kadar öğeyi almaya çalışın
      const element = (await getDOMElementAsync()) as HTMLElement | null;
      expect(element).toBeTruthy();
      expect(element.dataset.initialized).toBeTruthy();
      return element;
    },
    {
      timeout: 500, // varsayılan 1000'dir
      interval: 20, // varsayılan 50'dir
    }
  );
  expect(element).toBeInstanceOf(HTMLElement);
});

vi.useFakeTimers kullanılıyorsa, vi.waitFor her kontrol geri çağrısında otomatik olarak vi.advanceTimersByTime(interval)'ı çağırır.

vi.waitUntil

Tip: <T>(callback: WaitUntilCallback<T>, options?: number | WaitUntilOptions) => Promise<T>
Sürüm: Vitest 0.34.5'ten beri

Bu fonksiyon vi.waitFor fonksiyonuna benzerdir, ancak geri çağırım fonksiyonu bir hata fırlatırsa, yürütme hemen durdurulur ve bir hata mesajı alınır. Eğer geri çağırım fonksiyonu falsy bir değer dönerse, bir sonraki kontrol truthy bir değer dönene kadar devam edecektir. Bu, bir sonraki adımı atmadan önce bir şeyin var olmasını beklemeniz gerektiğinde kullanışlıdır.

Aşağıdaki örneğe bakın. Öğenin sayfada görünmesini beklemek için vi.waitUntil'ı kullanabiliriz ve ardından öğeyle bir şeyler yapabiliriz.

import { expect, test, vi } from 'vitest';

test('Öğe doğru şekilde oluşturuluyor', async () => {
  const element = await vi.waitUntil(() => document.querySelector('.element'), {
    timeout: 500, // varsayılan 1000'dir
    interval: 20, // varsayılan 50'dir
  });

  // öğeyle bir şeyler yapın
  expect(element.querySelector('.element-child')).toBeTruthy();
});

Vi ​

vi.advanceTimersByTime ​

vi.advanceTimersByTimeAsync ​

vi.advanceTimersToNextTimer ​

vi.advanceTimersToNextTimerAsync ​

vi.getTimerCount ​

vi.clearAllMocks ​

vi.clearAllTimers ​

vi.dynamicImportSettled ​

vi.fn ​

vi.getMockedSystemTime ​

vi.getRealSystemTime ​

vi.hoisted ​

vi.mock ​

vi.doMock ​

vi.mocked ​

vi.importActual ​

vi.importMock ​

vi.resetAllMocks ​

vi.resetConfig ​

vi.resetModules ​

vi.restoreAllMocks ​

vi.stubEnv ​

vi.unstubAllEnvs ​

vi.stubGlobal ​

vi.unstubAllGlobals ​

vi.runAllTicks ​

vi.runAllTimers ​

vi.runAllTimersAsync ​

vi.runOnlyPendingTimers ​

vi.runOnlyPendingTimersAsync ​

vi.setSystemTime ​

vi.setConfig ​

vi.spyOn ​

vi.stubGlobal ​

vi.unmock ​

vi.doUnmock ​

vi.useFakeTimers ​

vi.isFakeTimers ​

vi.useRealTimers ​

vi.waitFor ​

vi.waitUntil ​

Vi

vi.advanceTimersByTime

vi.advanceTimersByTimeAsync

vi.advanceTimersToNextTimer

vi.advanceTimersToNextTimerAsync

vi.getTimerCount

vi.clearAllMocks

vi.clearAllTimers

vi.dynamicImportSettled

vi.fn

vi.getMockedSystemTime

vi.getRealSystemTime

vi.hoisted

vi.mock

vi.doMock

vi.mocked

vi.importActual

vi.importMock

vi.resetAllMocks

vi.resetConfig

vi.resetModules

vi.restoreAllMocks

vi.stubEnv

vi.unstubAllEnvs

vi.stubGlobal

vi.unstubAllGlobals

vi.runAllTicks

vi.runAllTimers

vi.runAllTimersAsync

vi.runOnlyPendingTimers

vi.runOnlyPendingTimersAsync

vi.setSystemTime

vi.setConfig

vi.spyOn

vi.stubGlobal

vi.unmock

vi.doUnmock

vi.useFakeTimers

vi.isFakeTimers

vi.useRealTimers

vi.waitFor

vi.waitUntil