Test API Başvurusu

Aşağıdaki tipler, tip tanımlarında kullanılır:

type Awaitable<T> = T | PromiseLike<T>;
type TestFunction = () => Awaitable<void>;

interface TestOptions {
  /**
   * Testin yürütülmesi çok uzun sürerse başarısız olur.
   */
  timeout?: number;
  /**
   * Testin başarısız olması durumunda belirli sayıda yeniden denenmesini sağlar.
   *
   * @default 0
   */
  retry?: number;
  /**
   * Aynı testi, her seferinde başarısız olsa bile birkaç kez tekrarlayabilir.
   * "retry" (yeniden deneme) seçeneğiniz varsa ve test başarısız olursa, her döngüde her yeniden deneme kullanılır.
   * Rastgele başarısızlıkları ayıklamak için kullanışlıdır.
   *
   * @default 0
   */
  repeats?: number;
}

Bir test fonksiyonu bir promise döndürdüğünde, test çalıştırıcısı asenkron işlemlerin tamamlanmasını bekleyecektir. Promise reddedilirse, test başarısız olur.

TIP

Jest'te, TestFunction aynı zamanda (done: DoneCallback) => void tipinde de olabilir. Bu form kullanıldığında, done çağrılana kadar test tamamlanmaz. async bir fonksiyon kullanarak aynı şeyi elde edebilirsiniz, Migration guide Done Callback section bölümüne bakın.

test

Tip: (name: string | Function, fn: TestFunction, timeout?: number | TestOptions) => void
Takma ad: it
test, birbiriyle ilişkili beklentiler kümesini tanımlar. Test adını ve test edilecek beklentileri içeren bir fonksiyonu alır.
İsteğe bağlı olarak, testin tamamlanması için ne kadar bekleneceğini belirtmek üzere bir zaman aşımı (milisaniye cinsinden) sağlayabilirsiniz. Varsayılan değer 5 saniyedir ve testTimeout ile global olarak yapılandırılabilir.
ts
```
import { expect, test } from 'vitest';

test('beklendiği gibi çalışmalı', () => {
  expect(Math.sqrt(4)).toBe(2);
});
```

test.extend

Tip: <T extends Record<string, any>>(fixtures: Fixtures<T>): TestAPI<ExtraContext & T>
Takma ad: it.extend

Versiyon: Vitest 0.32.3

Özel test verileriyle test bağlamını genişletmek için test.extend kullanın. Bu, yeni bir test fonksiyonu döndürür ve aynı zamanda genişletilebilir, böylece daha fazla test verisi ekleyebilir veya genişleterek mevcut test verilerini değiştirebilirsiniz. Daha fazla bilgi için Extend Test Context bölümüne bakın.

import { expect, test } from 'vitest';

const todos = [];
const archive = [];

const myTest = test.extend({
  todos: async ({ task }, use) => {
    todos.push(1, 2, 3);
    await use(todos);
    todos.length = 0;
  },
  archive,
});

myTest('öğe ekle', ({ todos }) => {
  expect(todos.length).toBe(3);

  todos.push(4);
  expect(todos.length).toBe(4);
});

test.skip

Tip: (name: string | Function, fn: TestFunction, timeout?: number | TestOptions) => void

Takma ad: it.skip

Belirli testleri çalıştırmayı atlamak istiyorsanız, ancak herhangi bir nedenle kodu silmek istemiyorsanız, bunları çalıştırmaktan kaçınmak için test.skip kullanabilirsiniz.

import { assert, test } from 'vitest';

test.skip('atlanan test', () => {
  // Test atlandı, hata yok
  assert.equal(Math.sqrt(4), 3);
});

Ayrıca, bağlam üzerinde skip fonksiyonunu çağırarak testi dinamik olarak atlayabilirsiniz:

import { assert, test } from 'vitest';

test('atlanan test', context => {
  context.skip();
  // Test atlandı, hata yok
  assert.equal(Math.sqrt(4), 3);
});

test.skipIf

Tip: (condition: any) => Test
Takma ad: it.skipIf
Bazı durumlarda testleri farklı ortamlarda birden çok kez çalıştırabilirsiniz ve testlerin bazıları ortama özgü olabilir. Test kodunu if ile sarmalamak yerine, koşul sağlandığında testi atlamak için test.skipIf kullanabilirsiniz.
ts
```
import { assert, test } from 'vitest';

const isDev = process.env.NODE_ENV === 'development';

test.skipIf(isDev)('sadece prod testi', () => {
  // bu test yalnızca üretim ortamında çalışır
});
```

WARNING

Vitest'i tip denetleyicisi olarak kullanırken bu sözdizimini kullanamazsınız.

test.runIf

Tip: (condition: any) => Test

Takma ad: it.runIf

test.skipIf 'in tersidir.

import { assert, test } from 'vitest';

const isDev = process.env.NODE_ENV === 'development';

test.runIf(isDev)('sadece geliştirme testi', () => {
  // bu test yalnızca geliştirme ortamında çalışır
});

WARNING

Vitest'i tip denetleyicisi olarak kullanırken bu sözdizimini kullanamazsınız.

test.only

Tip: (name: string | Function, fn: TestFunction, timeout?: number) => void
Takma ad: it.only
Belirli bir test grubunda sadece belirli testleri çalıştırmak için test.only kullanın. Bu, hata ayıklama sırasında faydalıdır.
İsteğe bağlı olarak, testin tamamlanması için ne kadar bekleneceğini belirtmek üzere bir zaman aşımı (milisaniye cinsinden) sağlayabilirsiniz. Varsayılan değer 5 saniyedir ve testTimeout ile global olarak yapılandırılabilir.
ts
```
import { assert, test } from 'vitest';

test.only('test', () => {
  // Sadece bu test (ve only ile işaretlenmiş diğerleri) çalıştırılır
  assert.equal(Math.sqrt(4), 2);
});
```
Bazen, çıktıyı kirleten tüm test paketinden diğer tüm testleri yok sayarak, belirli bir dosyada only testlerini çalıştırmak çok yararlıdır.
Bunu yapmak için, söz konusu testleri içeren belirli bir dosyayla vitest çalıştırın.
```
# vitest interesting.test.ts
```

test.concurrent

Tip: (name: string | Function, fn: TestFunction, timeout?: number) => void

Takma ad: it.concurrent

test.concurrent, ardışık testlerin paralel olarak çalıştırılacağını belirtir. Test adını, çalıştırılacak testlerle birlikte bir asenkron fonksiyonu ve isteğe bağlı bir zaman aşımını (milisaniye cinsinden) alır.

import { describe, test } from 'vitest';

// Eş zamanlı olarak işaretlenmiş testler paralel olarak çalıştırılacaktır
describe('suite', () => {
  test('seri test', async () => {
    /* ... */
  });
  test.concurrent('eşzamanlı test 1', async () => {
    /* ... */
  });
  test.concurrent('eşzamanlı test 2', async () => {
    /* ... */
  });
});

test.skip, test.only ve test.todo eşzamanlı testlerle çalışır. Aşağıdaki tüm kombinasyonlar geçerlidir:

test.concurrent(/* ... */);
test.skip.concurrent(/* ... */); // veya test.concurrent.skip(/* ... */)
test.only.concurrent(/* ... */); // veya test.concurrent.only(/* ... */)
test.todo.concurrent(/* ... */); // veya test.concurrent.todo(/* ... */)

Paralel testler çalıştırılırken, doğru testin algılandığından emin olmak için Anlık Görüntüler ve Onaylamalar yerel Test Context 'ten expect kullanmalıdır.

test.concurrent('test 1', async ({ expect }) => {
  expect(foo).toMatchSnapshot();
});
test.concurrent('test 2', async ({ expect }) => {
  expect(foo).toMatchSnapshot();
});

WARNING

Vitest'i tip denetleyicisi olarak kullanırken bu sözdizimini kullanamazsınız.

test.todo

Tip: (name: string | Function) => void
Takma ad: it.todo
Daha sonra uygulanacak testleri taslak olarak işaretlemek için test.todo kullanın. Raporda testler için bir giriş gösterilecektir, böylece hala kaç test uygulamanız gerektiğini bilirsiniz.
ts
```
// Bu test için raporda bir giriş gösterilecektir
test.todo('uygulanmamış test');
```

test.fails

Tip: (name: string | Function, fn: TestFunction, timeout?: number) => void

Takma ad: it.fails

Bir doğrulamanın başarısız olmasının beklendiğini belirtmek için test.fails kullanın.

import { expect, test } from 'vitest';

function myAsyncFunc() {
  return new Promise(resolve => resolve(1));
}
test.fails('başarısız olması beklenen test', async () => {
  await expect(myAsyncFunc()).rejects.toBe(1);
});

WARNING

Vitest'i tip denetleyicisi olarak kullanırken bu sözdizimini kullanamazsınız.

test.each

Tip: (cases: ReadonlyArray<T>, ...args: any[]) => void

Takma ad: it.each

Aynı testi farklı değişkenlerle çalıştırmanız gerektiğinde test.each kullanın. Test fonksiyonu parametrelerinin sırasına göre test adında printf formatı ile parametreler ekleyebilirsiniz.

%s: string (dize)
%d: number (sayı)
%i: integer (tamsayı)
%f: floating point value (kayan nokta değeri)
%j: json
%o: object (nesne)
%#: test durumunun indeksi
%%: tek yüzde işareti ('%')

test.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('add(%i, %i) -> %i', (a, b, expected) => {
  expect(a + b).toBe(expected);
});

// çıktısı
// ✓ add(1, 1) -> 2
// ✓ add(1, 2) -> 3
// ✓ add(2, 1) -> 3

Nesneleri argüman olarak kullanıyorsanız, nesne özelliklerine $ önekiyle de erişebilirsiniz:

test.each([
  { a: 1, b: 1, expected: 2 },
  { a: 1, b: 2, expected: 3 },
  { a: 2, b: 1, expected: 3 },
])('add($a, $b) -> $expected', ({ a, b, expected }) => {
  expect(a + b).toBe(expected);
});

// çıktısı
// ✓ add(1, 1) -> 2
// ✓ add(1, 2) -> 3
// ✓ add(2, 1) -> 3

Nesneleri argüman olarak kullanıyorsanız, Nesne özelliklerine . ile de erişebilirsiniz:

test.each`
  a             | b      | expected
  ${{ val: 1 }} | ${'b'} | ${'1b'}
  ${{ val: 2 }} | ${'b'} | ${'2b'}
  ${{ val: 3 }} | ${'b'} | ${'3b'}
`('add($a.val, $b) -> $expected', ({ a, b, expected }) => {
  expect(a.val + b).toBe(expected);
});

// çıktısı
// ✓ add(1, b) -> 1b
// ✓ add(2, b) -> 2b
// ✓ add(3, b) -> 3b

Vitest 0.25.3'ten başlayarak, şablon dize tablosunu da kullanabilirsiniz.

İlk satır, | ile ayrılmış sütun adları olmalıdır;
${value} sözdizimini kullanarak şablon değişmez ifadeleri olarak sağlanan bir veya daha fazla sonraki veri satırı.

test.each`
  a             | b      | expected
  ${1}          | ${1}   | ${2}
  ${'a'}        | ${'b'} | ${'ab'}
  ${[]}         | ${'b'} | ${'b'}
  ${{}}         | ${'b'} | ${'[object Object]b'}
  ${{ asd: 1 }} | ${'b'} | ${'[object Object]b'}
`('returns $expected when $a is added $b', ({ a, b, expected }) => {
  expect(a + b).toBe(expected);
});

TestContext'e erişmek istiyorsanız, tek bir testle describe.each kullanın.

TIP

Vitest, $values'u chai format yöntemiyle işler. Değer çok kısaltılmışsa, yapılandırma dosyanızda chaiConfig.truncateThreshold değerini artırabilirsiniz.

WARNING

Vitest'i tip denetleyicisi olarak kullanırken bu sözdizimini kullanamazsınız.

bench

Tip: (name: string | Function, fn: BenchFunction, options?: BenchOptions) => void

bench bir performans testi (benchmark) tanımlar. Vitest terimleriyle performans testi, bir dizi işlemi tanımlayan bir fonksiyondur. Vitest, farklı performans sonuçlarını görüntülemek için bu fonksiyonu birden çok kez çalıştırır.

Vitest, arka planda tinybench kütüphanesini kullanır ve bu kütüphanenin üçüncü argüman olarak kullanılabilecek tüm seçeneklerini devralır.

import { bench } from 'vitest';

bench(
  'normal sıralama',
  () => {
    const x = [1, 5, 4, 2, 3];
    x.sort((a, b) => {
      return a - b;
    });
  },
  { time: 1000 }
);

export interface Options {
  /**
   * Bir performans testi görevinin çalışması için gereken süre (milisaniye).
   * @default 500
   */
  time?: number;

  /**
   * Süre seçeneği dolmuş olsa bile bir görevin kaç kez çalıştırılması gerektiği.
   * @default 10
   */
  iterations?: number;

  /**
   * Milisaniye cinsinden geçerli zaman damgasını almak için fonksiyon.
   */
  now?: () => number;

  /**
   * Performans testini durdurmak için bir AbortSignal.
   */
  signal?: AbortSignal;

  /**
   * Hazırlık süresi (milisaniye).
   * @default 100ms
   */
  warmupTime?: number;

  /**
   * Hazırlık yinelemeleri.
   * @default 5
   */
  warmupIterations?: number;

  /**
   * Her performans testi döngüsünden önce çalıştırılacak kurulum fonksiyonu.
   */
  setup?: Hook;

  /**
   * Her performans testi döngüsünden sonra çalıştırılacak temizleme fonksiyonu.
   */
  teardown?: Hook;
}

bench.skip

Tip: (name: string | Function, fn: BenchFunction, options?: BenchOptions) => void

Belirli performans testlerini çalıştırmayı atlamak için bench.skip sözdizimini kullanabilirsiniz.

import { bench } from 'vitest';

bench.skip('normal sıralama', () => {
  const x = [1, 5, 4, 2, 3];
  x.sort((a, b) => {
    return a - b;
  });
});

bench.only

Tip: (name: string | Function, fn: BenchFunction, options?: BenchOptions) => void

Belirli bir performans testi grubunda sadece belirli performans testlerini çalıştırmak için bench.only kullanın. Bu, hata ayıklama sırasında kullanışlıdır.

import { bench } from 'vitest';

bench.only('normal sıralama', () => {
  const x = [1, 5, 4, 2, 3];
  x.sort((a, b) => {
    return a - b;
  });
});

bench.todo

Tip: (name: string | Function) => void

Daha sonra uygulanacak performans testlerini taslak olarak işaretlemek için bench.todo kullanın.

import { bench } from 'vitest';

bench.todo('uygulanmamış test');

describe

Bir dosyanın en üst seviyesinde test veya bench fonksiyonlarını kullandığınızda, bu fonksiyonlar otomatik olarak o dosyanın bir parçası olarak kabul edilir. describe kullanarak, mevcut kapsamda yeni bir test grubu tanımlayabilirsiniz. Bu, ilgili testlerden, performans testlerinden ve diğer iç içe geçmiş test gruplarından oluşan bir kümedir. Bir test grubu, testlerinizi ve performans testlerinizi düzenlemenizi sağlayarak raporların daha anlaşılır olmasını sağlar.

// basic.spec.ts
// testleri düzenleme

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

const person = {
  isActive: true,
  age: 32,
};

describe('person', () => {
  test('person tanımlı mı?', () => {
    expect(person).toBeDefined();
  });

  test('aktif', () => {
    expect(person.isActive).toBeTruthy();
  });

  test('yaş sınırı', () => {
    expect(person.age).toBeLessThanOrEqual(32);
  });
});

// basic.bench.ts
// performans testlerini düzenleme

import { bench, describe } from 'vitest';

describe('sort', () => {
  bench('normal', () => {
    const x = [1, 5, 4, 2, 3];
    x.sort((a, b) => {
      return a - b;
    });
  });

  bench('reverse', () => {
    const x = [1, 5, 4, 2, 3];
    x.reverse().sort((a, b) => {
      return a - b;
    });
  });
});

Testler veya performans testleri için hiyerarşik bir yapınız varsa, describe bloklarını iç içe de kullanabilirsiniz:

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

function numberToCurrency(value) {
  if (typeof value !== 'number') throw new Error('Value must be a number');

  return value
    .toFixed(2)
    .toString()
    .replace(/\B(?=(\d{3})+(?!\d))/g, ',');
}

describe('numberToCurrency', () => {
  describe('geçersiz sayı verildiğinde', () => {
    test('sayı olmayan karakterlerden oluştuğunda hata vermeli', () => {
      expect(() => numberToCurrency('abc')).toThrowError();
    });
  });

  describe('geçerli bir sayı verildiğinde', () => {
    test('doğru para birimi formatını döndürür', () => {
      expect(numberToCurrency(10000)).toBe('10,000.00');
    });
  });
});

describe.skip

Tip: (name: string | Function, fn: TestFunction, options?: number | TestOptions) => void

Belirli bir describe bloğunun çalıştırılmasını engellemek için bir test grubu içinde describe.skip kullanın.

import { assert, describe, test } from 'vitest';

describe.skip('atlanmış suite', () => {
  test('sqrt', () => {
    // Suite atlandı, hata yok
    assert.equal(Math.sqrt(4), 3);
  });
});

describe.skipIf

Tip: (condition: any) => void
Bazı durumlarda, test gruplarını farklı ortamlarda birden çok kez çalıştırabilirsiniz ve test gruplarının bazıları ortama özgü olabilir. Test grubunu if ile sarmak yerine, koşul doğru olduğunda test grubunu atlamak için describe.skipIf kullanabilirsiniz.
ts
```
import { describe, test } from 'vitest';

const isDev = process.env.NODE_ENV === 'development';

describe.skipIf(isDev)('yalnızca prod testi', () => {
  // bu test sadece production'da çalışır
});
```

WARNING

Vitest'i tip denetleyicisi (type checker) olarak kullanırken bu sözdizimini kullanamazsınız.

describe.only

Tip: (name: string | Function, fn: TestFunction, options?: number | TestOptions) => void
Yalnızca belirli test gruplarını çalıştırmak için describe.only kullanın.
ts
```
// Yalnızca bu test grubu (ve only ile işaretlenmiş diğerleri) çalıştırılır
describe.only('suite', () => {
  test('sqrt', () => {
    assert.equal(Math.sqrt(4), 3);
  });
});

describe('diğer suite', () => {
  // ... atlanacak
});
```
Bazen, çıktıyı kirleten tüm test kümesinden diğer tüm testleri yok sayarak, belirli bir dosyada only testlerini çalıştırmak çok yararlıdır.
Bunu yapmak için, vitest'i söz konusu testleri içeren belirli bir dosyayla çalıştırın.
```
# vitest interesting.test.ts
```

describe.concurrent

Tip: (name: string | Function, fn: TestFunction, options?: number | TestOptions) => void

Bir suite içinde describe.concurrent kullanmak, o suite'deki tüm testlerin paralel olarak çalıştırılacağını belirtir.

// Bu suite içindeki tüm testler paralel olarak çalıştırılacak
describe.concurrent('suite', () => {
  test('eşzamanlı test 1', async () => {
    /* ... */
  });
  test('eşzamanlı test 2', async () => {
    /* ... */
  });
  test.concurrent('eşzamanlı test 3', async () => {
    /* ... */
  });
});

.skip, .only ve .todo eşzamanlı suite'lerle çalışır. Aşağıdaki tüm kombinasyonlar geçerlidir:

describe.concurrent(/* ... */);
describe.skip.concurrent(/* ... */); // veya describe.concurrent.skip(/* ... */)
describe.only.concurrent(/* ... */); // veya describe.concurrent.only(/* ... */)
describe.todo.concurrent(/* ... */); // veya describe.concurrent.todo(/* ... */)

Eşzamanlı testlerde, doğru testin belirlenmesi için Anlık Görüntüler ve Doğrulamalar, yerel Test Ortamı'ndan gelen expect fonksiyonunu kullanmalıdır.

describe.concurrent('suite', () => {
  test('eşzamanlı test 1', async ({ expect }) => {
    expect(foo).toMatchSnapshot();
  });
  test('eşzamanlı test 2', async ({ expect }) => {
    expect(foo).toMatchSnapshot();
  });
});

WARNING

Vitest'i tip denetleyicisi (type checker) olarak kullanırken bu sözdizimini kullanamazsınız.

describe.sequential

Tip: (name: string | Function, fn: TestFunction, options?: number | TestOptions) => void

Bir suite içinde describe.sequential kullanmak, o suite'deki tüm testlerin sıralı olarak çalıştırılacağını belirtir. Bu, testleri describe.concurrent içinde veya --sequence.concurrent komut seçeneğiyle sıralı olarak çalıştırmak istediğinizde kullanışlıdır.

describe.concurrent('suite', () => {
  test('eşzamanlı test 1', async () => {
    /* ... */
  });
  test('eşzamanlı test 2', async () => {
    /* ... */
  });

  describe.sequential('', () => {
    test('sıralı test 1', async () => {
      /* ... */
    });
    test('sıralı test 2', async () => {
      /* ... */
    });
  });
});

describe.shuffle

Tip: (name: string | Function, fn: TestFunction, options?: number | TestOptions) => void
Vitest, tüm testleri CLI bayrağı --sequence.shuffle veya yapılandırma seçeneği sequence.shuffle aracılığıyla rastgele sırada çalıştırmanın bir yolunu sağlar, ancak test kümenizin yalnızca bir bölümünün testleri rastgele sırada çalıştırmasını istiyorsanız, bunu bu yöntemle işaretleyebilirsiniz.
ts
```
describe.shuffle('suite', () => {
  test('rastgele test 1', async () => {
    /* ... */
  });
  test('rastgele test 2', async () => {
    /* ... */
  });
  test('rastgele test 3', async () => {
    /* ... */
  });
});
// Sıralama, yapılandırmadaki `sequence.seed` seçeneğine bağlıdır (varsayılan: `Date.now()`)
```

.skip, .only ve .todo rastgele suite'lerle çalışır.

WARNING

Vitest'i tip denetleyicisi (type checker) olarak kullanırken bu sözdizimini kullanamazsınız.

describe.todo

Tip: (name: string | Function) => void
Daha sonra uygulanacak suite'leri taslak olarak bırakmak için describe.todo kullanın. Raporda testler için bir girdi gösterilecektir, böylece hala kaç test uygulamanız gerektiğini bilirsiniz.
ts
```
// Bu suite için raporda bir girdi gösterilecektir
describe.todo('uygulanmamış suite');
```

describe.each

Tip: (cases: ReadonlyArray<T>, ...args: any[]): (name: string | Function, fn: (...args: T[]) => void, options?: number | TestOptions) => void

Aynı verilere bağlı birden fazla testiniz varsa describe.each kullanın.

describe.each([
  { a: 1, b: 1, expected: 2 },
  { a: 1, b: 2, expected: 3 },
  { a: 2, b: 1, expected: 3 },
])('describe object add($a, $b)', ({ a, b, expected }) => {
  test(`returns ${expected}`, () => {
    expect(a + b).toBe(expected);
  });

  test(`döndürülen değer ${expected}'dan büyük olmamalı`, () => {
    expect(a + b).not.toBeGreaterThan(expected);
  });

  test(`döndürülen değer ${expected}'dan küçük olmamalı`, () => {
    expect(a + b).not.toBeLessThan(expected);
  });
});

Vitest 0.25.3'ten başlayarak, şablon metin tablosunu da kullanabilirsiniz.

İlk satır, | ile ayrılmış sütun adları olmalıdır;
${value} sözdizimini kullanarak şablon değişmez ifadeleri olarak sağlanan bir veya daha fazla sonraki veri satırı.

describe.each`
  a             | b      | expected
  ${1}          | ${1}   | ${2}
  ${'a'}        | ${'b'} | ${'ab'}
  ${[]}         | ${'b'} | ${'b'}
  ${{}}         | ${'b'} | ${'[object Object]b'}
  ${{ asd: 1 }} | ${'b'} | ${'[object Object]b'}
`('describe template string add($a, $b)', ({ a, b, expected }) => {
  test(`returns ${expected}`, () => {
    expect(a + b).toBe(expected);
  });
});

WARNING

Vitest'i tip denetleyicisi (type checker) olarak kullanırken bu sözdizimini kullanamazsınız.

Kurulum ve Temizleme

Bu fonksiyonlar, kurulum ve temizleme işlemlerini tekrar tekrar yazmaktan kurtulmak için testlerin yaşam döngüsüne müdahale etmenizi sağlar. Bunlar mevcut bağlama uygulanır: en üst düzeyde kullanılırlarsa dosyaya veya bir describe bloğunun içindelerse mevcut suite'e. Vitest'i bir tip denetleyicisi olarak çalıştırdığınızda bu kancalar çağrılmaz.

beforeEach

Tip: beforeEach(fn: () => Awaitable<void>, timeout?: number)
Mevcut kapsamdaki her test çalıştırılmadan önce çağrılacak bir geri çağırma fonksiyonu kaydedin. Fonksiyon bir promise döndürürse, Vitest test çalıştırmadan önce promise'in çözülmesini bekler.
İsteğe bağlı olarak, sonlandırmadan önce ne kadar bekleneceğini tanımlayan bir süre sınırı (milisaniye cinsinden) geçirebilirsiniz. Varsayılan değer 5 saniyedir.
ts
```
import { beforeEach } from 'vitest';

beforeEach(async () => {
  // Her testten önce mock'ları temizleyin ve test verileri ekleyin
  await stopMocking();
  await addUser({ name: 'John' });
});
```
Burada, beforeEach her test için kullanıcının eklendiğinden emin olur.
Vitest v0.10.0'dan beri, beforeEach isteğe bağlı bir temizleme işlevini de kabul eder (afterEach'e eşdeğer).
ts
```
import { beforeEach } from 'vitest';

beforeEach(async () => {
  // her testten önce bir kez çağrılır
  await prepareSomething();

  // temizleme fonksiyonu, her testten sonra bir kez çağrılır
  return async () => {
    await resetSomething();
  };
});
```

afterEach

Tip: afterEach(fn: () => Awaitable<void>, timeout?: number)
Mevcut kapsamdaki her test tamamlandıktan sonra çağrılacak bir geri çağırma fonksiyonu kaydedin. Fonksiyon bir promise döndürürse, Vitest devam etmeden önce promise'in çözülmesini bekler.
İsteğe bağlı olarak, sonlandırmadan önce ne kadar bekleneceğini belirtmek için bir süre sınırı (milisaniye cinsinden) sağlayabilirsiniz. Varsayılan değer 5 saniyedir.
ts
```
import { afterEach } from 'vitest';

afterEach(async () => {
  await clearTestingData(); // her testten sonra test verilerini silin
});
```
Burada, afterEach her test çalıştıktan sonra test verilerinin temizlendiğinden emin olur.

beforeAll

Tip: beforeAll(fn: () => Awaitable<void>, timeout?: number)
Mevcut kapsamdaki tüm testleri çalıştırmaya başlamadan önce bir kez çağrılacak bir geri çağırma fonksiyonu kaydedin. Fonksiyon bir promise döndürürse, Vitest testleri çalıştırmadan önce promise'in çözülmesini bekler.
İsteğe bağlı olarak, sonlandırmadan önce ne kadar bekleneceğini belirtmek için bir süre sınırı (milisaniye cinsinden) sağlayabilirsiniz. Varsayılan değer 5 saniyedir.
ts
```
import { beforeAll } from 'vitest';

beforeAll(async () => {
  await startMocking(); // tüm testlerden önce bir kez çağrılır
});
```
Burada beforeAll, testler çalıştırılmadan önce sahte verilerin hazırlandığından emin olur.
Vitest v0.10.0'dan beri, beforeAll isteğe bağlı bir temizleme işlevini de kabul eder (afterAll'e eşdeğer).
ts
```
import { beforeAll } from 'vitest';

beforeAll(async () => {
  // tüm testlerden önce bir kez çağrılır
  await startMocking();

  // temizleme fonksiyonu, tüm testlerden sonra bir kez çağrılır
  return async () => {
    await stopMocking();
  };
});
```

afterAll

Tip: afterAll(fn: () => Awaitable<void>, timeout?: number)
Mevcut kapsamdaki tüm testler çalıştırıldıktan sonra bir kez çağrılacak bir geri çağırma fonksiyonu kaydedin. Fonksiyon bir promise döndürürse, Vitest devam etmeden önce promise'in çözülmesini bekler.
İsteğe bağlı olarak, sonlandırmadan önce ne kadar bekleneceğini belirtmek için bir süre sınırı (milisaniye cinsinden) sağlayabilirsiniz. Varsayılan değer 5 saniyedir.
ts
```
import { afterAll } from 'vitest';

afterAll(async () => {
  await stopMocking(); // bu metot tüm testlerden sonra çağrılır
});
```
Burada afterAll, stopMocking metodunun tüm testler çalıştırıldıktan sonra çağrıldığından emin olur.

Test API Başvurusu ​

test ​

test.extend ​

test.skip ​

test.skipIf ​

test.runIf ​

test.only ​

test.concurrent ​

test.todo ​

test.fails ​

test.each ​

bench ​

bench.skip ​

bench.only ​

bench.todo ​

describe ​

describe.skip ​

describe.skipIf ​

describe.only ​

describe.concurrent ​

describe.sequential ​

describe.shuffle ​

describe.todo ​

describe.each ​

Kurulum ve Temizleme ​

beforeEach ​

afterEach ​

beforeAll ​

afterAll ​

Test API Başvurusu

test

test.extend

test.skip

test.skipIf

test.runIf

test.only

test.concurrent

test.todo

test.fails

test.each

bench

bench.skip

bench.only

bench.todo

describe

describe.skip

describe.skipIf

describe.only

describe.concurrent

describe.sequential

describe.shuffle

describe.todo

describe.each

Kurulum ve Temizleme

beforeEach

afterEach

beforeAll

afterAll