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.

Çoğu seçenek, tercih ettiğiniz stili kullanmanıza olanak tanıyan nokta sözdizimi ve nesne sözdizimini destekler.

dot-syntaxobject-syntax

import { test } from 'vitest';

test.skip('skipped test', () => {
  // some logic that fails right now
});

import { test } from 'vitest';

test('skipped test', { skip: true }, () => {
  // some logic that fails right now
});

test

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.

import { expect, test } from 'vitest';

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

test.extend

Takma ad: it.extend

Ö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

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

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.

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

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

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.

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

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.sequential

Takma ad: it.sequential

test.sequential, bir testi sıralı olarak işaretler. Bu, describe.concurrent içinde veya --sequence.concurrent komut satırı seçeneğiyle testleri sıralı olarak çalıştırmak istediğinizde kullanışlıdır.

import { describe, test } from 'vitest';

// yapılandırma seçeneği ile { sequence: { concurrent: true } }
test('concurrent test 1', async () => {
  /* ... */
});
test('concurrent test 2', async () => {
  /* ... */
});

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

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

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

test.todo

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.

// Bu test için raporda bir giriş gösterilecektir
test.todo('uygulanmamış test');

test.fails

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

Takma ad: it.each

TIP

test.each, Jest uyumluluğu için sağlansa da, Vitest ayrıca TestContext entegrasyonu için ek bir özelliğe sahip test.for içerir.

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 ('%')

import { expect, test } from 'vitest';

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ı.

import { expect, test } from 'vitest';

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);
});

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.

test.for

Takma Ad: it.for

TestContext sağlamak için test.each'in alternatifi.

test.each'ten farkı, array durumunun argümanlarda nasıl sağlandığıdır. Diğer array olmayan durumlar (template string kullanımı dahil) tamamen aynı şekilde çalışır.

// `each` array durumunu dağıtır
test.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('add(%i, %i) -> %i', (a, b, expected) => { 
  expect(a + b).toBe(expected);
});

// `for` array durumunu dağıtmaz
test.for([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('add(%i, %i) -> %i', ([a, b, expected]) => { 
  expect(a + b).toBe(expected);
});

2. argüman TestContext'tir ve örneğin eşzamanlı snapshot için kullanılabilir.

test.concurrent.for([
  [1, 1],
  [1, 2],
  [2, 1],
])('add(%i, %i)', ([a, b], { expect }) => {
  expect(a + b).matchSnapshot();
});

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;

  /**
   * Bir görev başarısız olursa hata fırlatın (true ise olaylar çalışmayacaktır)
   */
  throws?: boolean;

  /**
   * 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;
}

Test durumu çalıştırıldıktan sonra çıktı yapısı bilgisi aşağıdaki gibidir:

  name                      hz     min     max    mean     p75     p99    p995    p999     rme  samples
· normal sorting  6,526,368.12  0.0001  0.3638  0.0002  0.0002  0.0002  0.0002  0.0004  ±1.41%   652638

export interface TaskResult {
  /*
   * Görev çalıştırılırken atılan son hata
   */
  error?: unknown;

  /**
   * Benchmark görevini (döngü) çalıştırmak için geçen süre (milisaniye).
   */
  totalTime: number;

  /**
   * Örneklerdeki minimum değer
   */
  min: number;
  /**
   * Örneklerdeki maksimum değer
   */
  max: number;

  /**
   * Saniyedeki işlem sayısı
   */
  hz: number;

  /**
   * Her işlemin ne kadar sürdüğü (ms)
   */
  period: number;

  /**
   * Her görev yineleme süresinin görev örnekleri (ms)
   */
  samples: number[];

  /**
   * Örneklerin ortalaması/ortalaması (popülasyon ortalamasının tahmini)
   */
  mean: number;

  /**
   * Örneklerin varyansı (popülasyon varyansının tahmini)
   */
  variance: number;

  /**
   * Örneklerin standart sapması (popülasyon standart sapmasının tahmini)
   */
  sd: number;

  /**
   * Ortalamanın standart hatası (örnek ortalamasının örnekleme dağılımının standart sapması olarak da bilinir)
   */
  sem: number;

  /**
   * Serbestlik derecesi
   */
  df: number;

  /**
   * Örneklerin kritik değeri
   */
  critical: number;

  /**
   * Hata payı
   */
  moe: number;

  /**
   * Göreceli hata payı
   */
  rme: number;

  /**
   * Medyan mutlak sapma
   */
  mad: number;

  /**
   * p50/medyan yüzdelik dilimi
   */
  p50: number;

  /**
   * p75 yüzdelik dilimi
   */
  p75: number;

  /**
   * p99 yüzdelik dilimi
   */
  p99: number;

  /**
   * p995 yüzdelik dilimi
   */
  p995: number;

  /**
   * p999 yüzdelik dilimi
   */
  p999: number;
}

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: number | string) {
  if (typeof value !== 'number') {
    throw new TypeError('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

Alias: suite.skip

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

Alias: suite.skipIf

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.

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.runIf

Takma ad: suite.runIf

describe.skipIf'in tersi.

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

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

describe.runIf(isDev)('dev only test suite', () => {
  // this test suite only runs in development
});

WARNING

Vitest'i bir tür denetleyicisi 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.

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

// 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

Alias: suite.concurrent

describe.concurrent tüm iç suite'leri ve testleri paralel olarak çalıştırır

import { describe, test } from 'vitest';

// Bu süit içindeki tüm süitler ve testler paralel olarak çalıştırılacaktır.
describe.concurrent('suite', () => {
  test('concurrent test 1', async () => {
    /* ... */
  });
  describe('concurrent suite 2', async () => {
    test('concurrent test inner 1', async () => {
      /* ... */
    });
    test('concurrent test inner 2', async () => {
      /* ... */
    });
  });
  test.concurrent('concurrent 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

Alias: suite.sequential

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.

import { describe, test } from 'vitest';

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

Alias: suite.shuffle

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.

import { describe, test } from 'vitest';

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

Alias: suite.todo

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.

// Bu suite için raporda bir girdi gösterilecektir
describe.todo('uygulanmamış suite');

describe.each

Alias: suite.each

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

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

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ı.

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

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.

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.

beforeEach isteğe bağlı bir temizleme işlevini de kabul eder (afterEach'e eşdeğer).

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.

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.

TIP

Vitest 1.3.0, onTestFinished kancasını ekledi. Test çalışması bittikten sonra herhangi bir durumu temizlemek için test yürütmesi sırasında bunu çağırabilirsiniz.

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.

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.

beforeAll isteğe bağlı bir temizleme işlevini de kabul eder (afterAll'e eşdeğer).

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.

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 Kancaları

Vitest, testin yürütülmesi sırasında çağırabileceğiniz ve testin çalışması bittiğinde durumu temizlemek için kullanabileceğiniz birkaç kanca sağlar.

WARNING

Bu kancalar, test gövdesinin dışında çağrılırsa bir hata verir.

onTestFinished

Bu kanca, test çalışması bittikten sonra her zaman çağrılır. Test sonucunu etkileyebileceğinden afterEach kancalarından sonra çağrılır. Mevcut test sonucuyla birlikte bir TaskResult nesnesi alır.

import { onTestFinished, test } from 'vitest';

test('performs a query', () => {
  const db = connectDb();
  onTestFinished(() => db.close());
  db.query('SELECT * FROM users');
});

WARNING

Testleri eşzamanlı olarak çalıştırıyorsanız, Vitest genel kancalarda eşzamanlı testleri izlemediğinden, her zaman test bağlamından onTestFinished kancasını kullanmanız gerekir:

import { test } from 'vitest';

test.concurrent('performs a query', ({ onTestFinished }) => {
  const db = connectDb();
  onTestFinished(() => db.close());
  db.query('SELECT * FROM users');
});

Bu kanca, yeniden kullanılabilir mantık oluştururken özellikle kullanışlıdır:

// bu ayrı bir dosyada olabilir
function getTestDb() {
  const db = connectMockedDb();
  onTestFinished(() => db.close());
  return db;
}

test('performs a user query', async () => {
  const db = getTestDb();
  expect(await db.query('SELECT * from users').perform()).toEqual([]);
});

test('performs an organization query', async () => {
  const db = getTestDb();
  expect(await db.query('SELECT * from organizations').perform()).toEqual([]);
});

TIP

Bu kanca her zaman ters sırada çağrılır ve sequence.hooks seçeneğinden etkilenmez.

onTestFailed

Bu kanca yalnızca test başarısız olduktan sonra çağrılır. Test sonucunu etkileyebileceğinden afterEach kancalarından sonra çağrılır. Mevcut test sonucuyla birlikte bir TaskResult nesnesi alır. Bu kanca, hata ayıklama için kullanışlıdır.

import { onTestFailed, test } from 'vitest';

test('performs a query', () => {
  const db = connectDb();
  onTestFailed(e => {
    console.log(e.result.errors);
  });
  db.query('SELECT * FROM users');
});

WARNING

Testleri eşzamanlı olarak çalıştırıyorsanız, Vitest genel kancalarda eşzamanlı testleri izlemediğinden, her zaman test bağlamından onTestFailed kancasını kullanmanız gerekir:

import { test } from 'vitest';

test.concurrent('performs a query', ({ onTestFailed }) => {
  const db = connectDb();
  onTestFailed(result => {
    console.log(result.errors);
  });
  db.query('SELECT * FROM users');
});

Test API Başvurusu ​

test ​

test.extend ​

test.skip ​

test.skipIf ​

test.runIf ​

test.only ​

test.concurrent ​

test.sequential ​

test.todo ​

test.fails ​

test.each ​

test.for ​

bench ​

bench.skip ​

bench.only ​

bench.todo ​

describe ​

describe.skip ​

describe.skipIf ​

describe.runIf ​

describe.only ​

describe.concurrent ​

describe.sequential ​

describe.shuffle ​

describe.todo ​

describe.each ​

Kurulum ve Temizleme ​

beforeEach ​

afterEach ​

beforeAll ​

afterAll ​

Test Kancaları ​

onTestFinished ​

onTestFailed ​

Test API Başvurusu

test

test.extend

test.skip

test.skipIf

test.runIf

test.only

test.concurrent

test.sequential

test.todo

test.fails

test.each

test.for

bench

bench.skip

bench.only

bench.todo

describe

describe.skip

describe.skipIf

describe.runIf

describe.only

describe.concurrent

describe.sequential

describe.shuffle

describe.todo

describe.each

Kurulum ve Temizleme

beforeEach

afterEach

beforeAll

afterAll

Test Kancaları

onTestFinished

onTestFailed