Test API Referansları

Aşağıdaki tip imzalarında kullanılan tipler şunlardır:

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

interface TestOptions {
  /**
   * Testin çok uzun sürmesi durumunda başarısız sayılmasını sağlar.
   */
  timeout?: number;
  /**
   * Testin başarısız olması durumunda belirli sayıda yeniden denenmesini sağlar.
   *
   * @default 0
   */
  retry?: number;
  /**
   * Testin, başarısız olsa bile belirli sayıda tekrarlanmasını sağlar.
   * "retry" seçeneği mevcutsa ve test başarısız olursa, her döngüde tüm yeniden deneme haklarını kullanır.
   * Rastgele oluşan hataların ayıklanması 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 beklentileri toplamak için promise'in çözülmesini bekler. Promise reddedilirse, test başarısız olur.

TIP

Jest'te, TestFunction aynı zamanda (done: DoneCallback) => void türünde de olabilir. Bu form kullanılırsa, done çağrılana kadar test tamamlanmayacaktır. Aynı şeyi async bir fonksiyon kullanarak da başarabilirsiniz, bkz. Taşıma kılavuzu Done Callback bölümü.

Seçenekleri bir fonksiyon üzerinde özellik zincirleme yöntemiyle tanımlayabilirsiniz:

import { test } from 'vitest';

test.skip('atlanan test', () => {
  // şu anda başarısız olan bazı mantık
});

test.concurrent.skip('atlanan eşzamanlı test', () => {
  // şu anda başarısız olan bazı mantık
});

Ancak ikinci argüman olarak bir nesne de sağlayabilirsiniz:

import { test } from 'vitest';

test('atlanan test', { skip: true }, () => {
  // şu anda başarısız olan bazı mantık
});

test('atlanan eşzamanlı test', { skip: true, concurrent: true }, () => {
  // şu anda başarısız olan bazı mantık
});

Her iki yöntem de tamamen aynı şekilde çalışır. Hangisinin kullanılacağı tamamen stilistik bir tercihtir.

Zaman aşımını son argüman olarak sağlıyorsanız, seçenekleri artık kullanamayacağınızı unutmayın:

import { test } from 'vitest';

// ✅ bu çalışır
test.skip('ağır test', () => {
  // ...
}, 10_000);

// ❌ bu çalışmaz
test(
  'ağır test',
  { skip: true },
  () => {
    // ...
  },
  10_000
);

Ancak, nesnenin içine bir zaman aşımı sağlayabilirsiniz:

import { test } from 'vitest';

// ✅ bu çalışır
test('ağır test', { skip: true, timeout: 10_000 }, () => {
  // ...
});

test

Takma Ad: it

test, bir dizi ilgili beklentiyi tanımlar. Test adını ve test edilecek beklentileri içeren bir fonksiyonu alır.

İsteğe bağlı olarak, sonlandırmadan önce ne kadar bekleneceğini belirtmek için bir zaman aşımı (milisaniye cinsinden) sağlayabilirsiniz. Varsayılan 5 saniyedir ve testTimeout ile global olarak yapılandırılabilir.

import { expect, test } from 'vitest';

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

test.extend

Takma Ad: it.extend

Test bağlamını özel hazırlıklarla genişletmek için test.extend kullanın. Bu, yeni bir test döndürecektir ve aynı zamanda genişletilebilir olduğundan, ihtiyacınız doğrultusunda daha fazla fikstür oluşturabilir veya mevcut olanları genişleterek geçersiz kılabilirsiniz. Daha fazla bilgi için Test Bağlamını Genişletme 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 kodu silmek istemiyorsanız, bu testlerin çalıştırılmasını önlemek için test.skip kullanabilirsiniz.

import { assert, test } from 'vitest';

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

Testi, kendi bağlamı üzerinde skip metodunu çağırarak dinamik olarak da atlayabilirsiniz:

import { assert, test } from 'vitest';

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

Vitest 3.1'den itibaren, koşul bilinmiyorsa, skip metoduna ilk argüman olarak bu koşulu sağlayabilirsiniz:

import { assert, test } from 'vitest';

test('atlanan test', context => {
  context.skip(Math.random() < 0.5, 'isteğe bağlı mesaj');
  // Test atlandı, hata yok
  assert.equal(Math.sqrt(4), 3);
});

test.skipIf

Takma Ad: it.skipIf

Bazı durumlarda testleri farklı ortamlarla birden çok kez çalıştırabilirsiniz ve bu testlerden bazıları ortama özgü olabilir. Test kodunu bir if ifadesiyle sarmak yerine, koşul doğru olduğunda testi atlamak için test.skipIf kullanabilirsiniz.

import { assert, test } from 'vitest';

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

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

WARNING

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

test.runIf

Takma Adı: it.runIf

test.skipIf öğesinin tersi.

import { assert, test } from 'vitest';

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

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

WARNING

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

test.only

Takma Ad: it.only

Belirli testleri belirli bir pakette çalıştırmak için test.only kullanın. Bu, hata ayıklama için kullanışlıdır.

import { assert, test } from 'vitest';

test.only('test', () => {
  // Yalnızca bu test (ve "only" ile işaretlenmiş diğerleri) çalıştırılır
  assert.equal(Math.sqrt(4), 2);
});

Bazen, tüm test paketindeki diğer testleri göz ardı ederek (bu durum çıktıyı kirletebilir), belirli bir dosyada yalnızca only olarak işaretlenmiş testleri çalıştırmak çok faydalıdır.

Bunu yapmak için, söz konusu testleri içeren belirli bir dosya ile vitest'i çalıştırın.

# vitest interesting.test.ts

test.concurrent

Takma Ad: it.concurrent

test.concurrent ardışık testlerin paralel olarak çalıştırılmasını sağlar. Test adını, toplanacak testleri içeren asenkron bir fonksiyonu ve isteğe bağlı bir zaman aşımı süresini (milisaniye cinsinden) alır.

import { describe, test } from 'vitest';

// Eşzamanlı olarak işaretlenmiş iki test paralel olarak çalıştırılır
describe('paket', () => {
  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(/* ... */)

Eşzamanlı testler çalıştırılırken, Anlık Görüntüler ve Onaylamalar, doğru testin algılandığından emin olmak için yerel Test Bağlamı içindeki 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 tür denetleyicisi olarak kullanırken bu sözdizimini kullanamazsınız.

test.sequential

Takma Ad: it.sequential

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

import { describe, test } from 'vitest';

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

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

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

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

test.todo

Takma Ad: it.todo

Daha sonra uygulanacak testleri taslak olarak belirtmek için test.todo kullanın. Raporunuzda bu testler için bir kayıt gösterilir, böylece henüz kaç testin uygulanması gerektiğini bilirsiniz.

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

test.fails

Takma Ad: it.fails

Bir onayın açıkça başarısız olacağını belirtmek için test.fails metodunu kullanın.

import { expect, test } from 'vitest';

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

WARNING

Vitest'i tür 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ğlanmış olsa da, Vitest'in TestContext entegre etmek için ek bir özelliğe sahip test.for özelliği de vardır.

Aynı testi farklı değişkenlerle çalıştırmanız gerektiğinde test.each kullanın. Test adı içinde printf biçimlendirmesi kullanarak, test fonksiyonu parametrelerinin sırasına göre parametreleri enjekte edebilirsiniz.

%s: dize
%d: sayı
%i: tam sayı
%f: ondalık değer
%j: json
%o: nesne
%#: test durumunun 0 tabanlı indeksi
%$: test durumunun 1 tabanlı indeksi
%%: tek yüzde işareti ('%')

import { expect, test } from 'vitest';

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

// bu, aşağıdaki çıktıyı döndürecektir
// ✓ ekle(1, 1) -> 2
// ✓ ekle(1, 2) -> 3
// ✓ ekle(2, 1) -> 3

Nesne özelliklerine ve dizi elemanlarına $ önekiyle de erişebilirsiniz:

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

// bu, aşağıdaki çıktıyı döndürecektir
// ✓ ekle(1, 1) -> 2
// ✓ ekle(1, 2) -> 3
// ✓ ekle(2, 1) -> 3

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

// bu, aşağıdaki çıktıyı döndürecektir
// ✓ ekle(1, 1) -> 2
// ✓ ekle(1, 2) -> 3
// ✓ ekle(2, 1) -> 3

Argüman olarak nesneler kullanıyorsanız, nesne niteliklerine . ile de erişebilirsiniz:

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

// bu, aşağıdaki çıktıyı döndürecektir
// ✓ ekle(1, b) -> 1b
// ✓ ekle(2, b) -> 2b
// ✓ ekle(3, b) -> 3b

Vitest 0.25.3'ten itibaren, şablon dizesi tablosunu da kullanabilirsiniz.

İlk satır, | ile ayrılmış sütun adları olmalıdır;
Bir veya daha fazla sonraki veri satırı, ${value} sözdizimi kullanılarak şablon değişmez ifadeleri olarak sağlanı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'}
`('$a $b eklendiğinde $expected döndürür', ({ a, b, expected }) => {
  expect(a + b).toBe(expected);
});

TIP

Vitest, $values değerlerini Chai'nin format metoduyla işler. Değer çok kısaltılmışsa, yapılandırma dosyanızdaki chaiConfig.truncateThreshold değerini artırabilirsiniz.

WARNING

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

test.for

Takma Ad: it.for

TestContext sağlamak için test.each metoduna bir alternatif.

test.each metodundan farkı, argümanlarda dizilerin nasıl sağlandığıdır. test.for metoduna dizi olmayan argümanlar (şablon dizesi kullanımı dahil) test.each metoduyla tamamen aynı şekilde çalışır.

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

// `for` dizileri yaymaz (argümanların etrafındaki köşeli parantezlere dikkat edin)
test.for([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('ekle(%i, %i) -> %i', ([a, b, expected]) => { 
  expect(a + b).toBe(expected);
});

argüman TestContext olup, örneğin eşzamanlı anlık görüntüler için kullanılabilir:

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

bench

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

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

Vitest, arka planda tinybench kütüphanesini kullanır ve üçüncü argüman olarak kullanılabilecek tüm seçeneklerini miras alı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 kıyaslama görevini çalıştırmak için gereken süre (milisaniye).
   * @default 500
   */
  time?: number;

  /**
   * Zaman seçeneği tamamlanmış olsa dahi bir görevin kaç kez çalışması gerektiği.
   * @default 10
   */
  iterations?: number;

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

  /**
   * Kıyaslamayı iptal etmek için kullanılan bir AbortSignal.
   */
  signal?: AbortSignal;

  /**
   * Bir görev başarısız olursa hata fırlatır (doğruysa olaylar çalışmaz).
   */
  throws?: boolean;

  /**
   * Isınma süresi (milisaniye cinsinden).
   * @default 100ms
   */
  warmupTime?: number;

  /**
   * Isınma iterasyonları.
   * @default 5
   */
  warmupIterations?: number;

  /**
   * Her kıyaslama görevinden (döngü) önce çalıştırılacak olan kurulum fonksiyonu.
   */
  setup?: Hook;

  /**
   * Her kıyaslama görevinden (döngü) sonra çalıştırılacak olan temizleme fonksiyonu.
   */
  teardown?: Hook;
}

Test senaryosu çalıştırıldıktan sonra, çıktı yapısı bilgileri aşağıdaki gibidir:

  name                      hz     min     max    mean     p75     p99    p995    p999     rme  samples
· normal sıralama  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örevi çalıştırılırken fırlatılan son hata.
   */
  error?: unknown;

  /**
   * Kıyaslama görevini (döngü) çalıştırmak için harcanan toplam süre (milisaniye cinsinden).
   */
  totalTime: number;

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

  /**
   * Saniye başına düşen işlem sayısı.
   */
  hz: number;

  /**
   * Her bir işlemin ne kadar sürdüğü (milisaniye cinsinden).
   */
  period: number;

  /**
   * Her görev iterasyon süresinin (milisaniye cinsinden) görev örnekleri.
   */
  samples: number[];

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

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

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

  /**
   * Ortalamanın standart hatası (diğer adıyla, örnek ortalamasının örnekleme dağılımının standart sapması).
   */
  sem: number;

  /**
   * Serbestlik dereceleri.
   */
  df: number;

  /**
   * Örneklem kritik değeri.
   */
  critical: number;

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

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

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

  /**
   * p50/medyan persentil.
   */
  p50: number;

  /**
   * p75 persentil.
   */
  p75: number;

  /**
   * p99 persentil.
   */
  p99: number;

  /**
   * p995 persentil.
   */
  p995: number;

  /**
   * p999 persentil.
   */
  p999: number;
}

bench.skip

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

Belirli kıyaslamaları çalıştırmayı atlamak için bench.skip metodunu 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

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

Belirli bir pakette yalnızca belirli kıyaslamaları çalıştırmak için bench.only metodunu 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

Tür: (name: string | Function) => void

Daha sonra uygulanacak kıyaslamaları taslak olarak belirtmek için bench.todo metodunu kullanın.

import { bench } from 'vitest';

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

describe

Dosyanın en üst düzeyinde test veya bench kullandığınızda, bunlar dosya için örtük paketin bir parçası olarak toplanır. describe kullanarak, mevcut bağlamda, ilgili testler veya kıyaslamalar ve diğer iç içe geçmiş paketler kümesi olarak yeni bir paket tanımlayabilirsiniz. Bir paket, testlerinizi ve kıyaslamalarınızı düzenlemenizi sağlayarak raporların daha net olmasını sağlar.

// basic.spec.ts
// testleri gruplama

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

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

describe('kişi', () => {
  test('kişi tanımlı', () => {
    expect(person).toBeDefined();
  });

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

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

// basic.bench.ts
// kıyaslamaları gruplama

import { bench, describe } from 'vitest';

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

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

Testlerinizin veya kıyaslamalarınızın bir hiyerarşisi varsa, iç içe describe blokları da kullanabilirsiniz:

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

function numberToCurrency(value: number | string) {
  if (typeof value !== 'number') {
    throw new TypeError('Değer bir sayı olmalıdır');
  }

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

describe('numberToCurrency', () => {
  describe('geçersiz bir sayı verildiğinde', () => {
    test('sayısal olmayan değerlerden oluşanların hata fırlatması', () => {
      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

Takma Ad: suite.skip

Belirli bir describe bloğunu çalıştırmaktan kaçınmak için bir pakette describe.skip metodunu kullanın.

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

describe.skip('atlanan paket', () => {
  test('sqrt', () => {
    // Paket atlandı, hata oluşmadı
    assert.equal(Math.sqrt(4), 3);
  });
});

describe.skipIf

Takma Ad: suite.skipIf

Bazı durumlarda, paketleri farklı ortamlarla birden çok kez çalıştırabilirsiniz ve bazı paketler ortama özgü olabilir. Paketi bir if ifadesiyle sarmak yerine, koşul doğru olduğunda paketi atlamak için describe.skipIf metodunu kullanabilirsiniz.

import { describe, test } from 'vitest';

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

describe.skipIf(isDev)('yalnızca üretim test paketi', () => {
  // bu test paketi yalnızca üretimde çalışır
});

WARNING

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

describe.runIf

Takma Ad: suite.runIf

describe.skipIf öğesinin tersi.

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

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

describe.runIf(isDev)('yalnızca geliştirme test paketi', () => {
  // bu test paketi yalnızca geliştirmede çalışır
});

WARNING

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

describe.only

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

Yalnızca belirli paketleri çalıştırmak için describe.only metodunu kullanın

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

// Yalnızca bu paket (ve "only" ile işaretlenmiş diğerleri) çalıştırılır
describe.only('paket', () => {
  test('sqrt', () => {
    assert.equal(Math.sqrt(4), 3);
  });
});

describe('diğer paket', () => {
  // ... atlanacaktır
});

Bunu yapmak için, söz konusu testleri içeren belirli bir dosya ile vitest'i çalıştırın.

# vitest interesting.test.ts

describe.concurrent

Takma Ad: suite.concurrent

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

import { describe, test } from 'vitest';

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

.skip, .only ve .todo eşzamanlı paketlerle ç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ı testler çalıştırılırken, Anlık Görüntüler ve Onaylamalar, doğru testin algılandığından emin olmak için yerel Test Bağlamı içindeki expect kullanmalıdır.

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

WARNING

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

describe.sequential

Takma Ad: suite.sequential

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

import { describe, test } from 'vitest';

describe.concurrent('paket', () => {
  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

Takma Ad: suite.shuffle

Vitest, --sequence.shuffle CLI bayrağı veya sequence.shuffle yapılandırma seçeneği aracılığıyla tüm testleri rastgele sırada çalıştırmanın bir yolunu sunar. Ancak, test paketinizin yalnızca bir kısmının testleri rastgele sırada çalıştırmasını istiyorsanız, bunu bu bayrakla işaretleyebilirsiniz.

import { describe, test } from 'vitest';

// veya describe('suite', { shuffle: true }, ...)
describe.shuffle('paket', () => {
  test('rastgele test 1', async () => {
    /* ... */
  });
  test('rastgele test 2', async () => {
    /* ... */
  });
  test('rastgele test 3', async () => {
    /* ... */
  });

  // `shuffle` miras alınır
  describe('hala rastgele', () => {
    test('rastgele 4.1', async () => {
      /* ... */
    });
    test('rastgele 4.2', async () => {
      /* ... */
    });
  });

  // içindeki karıştırmayı devre dışı bırak
  describe('rastgele değil', { shuffle: false }, () => {
    test('sıralı 5.1', async () => {
      /* ... */
    });
    test('sıralı 5.2', async () => {
      /* ... */
    });
  });
});
// sıralama, yapılandırmadaki `sequence.seed` seçeneğine bağlıdır (varsayılan olarak Date.now() kullanılır)

.skip, .only ve .todo rastgele paketlerle çalışır.

WARNING

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

describe.todo

Takma Ad: suite.todo

Daha sonra uygulanacak paketleri taslak olarak belirtmek için describe.todo metodunu kullanın. Raporunuzda bu testler için bir kayıt gösterilir, böylece henüz kaç testin uygulanması gerektiğini bilirsiniz.

// Bu paket için raporda bir giriş gösterilir
describe.todo('uygulanmamış paket');

describe.each

Takma Ad: suite.each

TIP

describe.each Jest uyumluluğu için sağlanmış olsa da, Vitest ayrıca argüman türlerini basitleştiren ve test.for ile uyumlu olan describe.for metoduna da sahiptir.

Aynı verilere bağlı birden fazla testiniz varsa describe.each metodunu 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 },
])('nesne ekle($a, $b) tanımla', ({ a, b, expected }) => {
  test(`${expected} döndürür`, () => {
    expect(a + b).toBe(expected);
  });

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

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

Vitest 0.25.3'ten itibaren, şablon dizesi tablosunu da kullanabilirsiniz.

İlk satır, | ile ayrılmış sütun adları olmalıdır;
Bir veya daha fazla sonraki veri satırı, ${value} sözdizimi kullanılarak şablon değişmez ifadeleri olarak sağlanı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'}
`('şablon dizesi ekle($a, $b) tanımla', ({ a, b, expected }) => {
  test(`${expected} döndürür`, () => {
    expect(a + b).toBe(expected);
  });
});

WARNING

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

describe.for

Takma Ad: suite.for

describe.each metodundan farkı, dizi durumunun argümanlarda nasıl sağlandığıdır. Dizi olmayan diğer durumlar (şablon dizesi kullanımı dahil) tamamen aynı şekilde çalışır.

// `each` dizi durumunu yayar
describe.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('ekle(%i, %i) -> %i', (a, b, expected) => { 
  test('test', () => {
    expect(a + b).toBe(expected);
  });
});

// `for` dizi durumunu yaymaz
describe.for([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('ekle(%i, %i) -> %i', ([a, b, expected]) => { 
  test('test', () => {
    expect(a + b).toBe(expected);
  });
});

Kurulum ve Yıkım

Bu fonksiyonlar, kurulum ve yıkım kodunu tekrarlamaktan kaçınmak amacıyla testlerin yaşam döngüsüne müdahale etmenizi sağlar. Mevcut bağlama uygulanırlar: eğer en üst düzeyde kullanılırlarsa dosya bağlamına, bir describe bloğunun içindelerse mevcut pakete uygulanırlar. Bu kancalar, Vitest'i bir tür denetleyicisi olarak çalıştırdığınızda çağrılmazlar.

beforeEach

Tür: beforeEach(fn: () => Awaitable<void>, timeout?: number)

Mevcut bağlamdaki her test çalıştırılmadan önce çağrılacak bir geri arama fonksiyonu kaydeder. Fonksiyon bir promise döndürürse, Vitest testi çalıştırmadan önce promise'in çözülmesini bekler.

İsteğe bağlı olarak, sonlandırmadan önce ne kadar bekleneceğini tanımlayan bir zaman aşımı (milisaniye cinsinden) geçirebilirsiniz. Varsayılan 5 saniyedir.

import { beforeEach } from 'vitest';

beforeEach(async () => {
  // Her test çalıştırılmadan önce mock'ları temizle ve bazı test verileri ekle
  await stopMocking();
  await addUser({ name: 'John' });
});

Burada, beforeEach her test için kullanıcının eklendiğinden emin olur.

beforeEach ayrıca isteğe bağlı bir temizleme fonksiyonu da kabul eder (afterEach ile eşdeğerdir).

import { beforeEach } from 'vitest';

beforeEach(async () => {
  // her test çalıştırılmadan önce bir kez çağrılır
  await prepareSomething();

  // temizleme fonksiyonu, her test çalıştırıldıktan sonra bir kez çağrılır
  return async () => {
    await resetSomething();
  };
});

afterEach

Tür: afterEach(fn: () => Awaitable<void>, timeout?: number)

Mevcut bağlamdaki her bir test tamamlandıktan sonra çağrılacak bir geri arama fonksiyonu kaydeder. 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 belirten bir zaman aşımı (milisaniye cinsinden) sağlayabilirsiniz. Varsayılan 5 saniyedir.

import { afterEach } from 'vitest';

afterEach(async () => {
  await clearTestingData(); // her test çalıştırıldıktan sonra test verilerini temizle
});

Burada, afterEach her test çalıştırıldıktan sonra test verilerinin temizlendiğinden emin olur.

TIP

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

beforeAll

Tür: beforeAll(fn: () => Awaitable<void>, timeout?: number)

Mevcut bağlamdaki tüm testler çalıştırılmaya başlamadan önce bir kez çağrılacak bir geri arama fonksiyonu kaydeder. 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 belirten bir zaman aşımı (milisaniye cinsinden) sağlayabilirsiniz. Varsayılan 5 saniyedir.

import { beforeAll } from 'vitest';

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

Burada beforeAll, testler çalıştırılmadan önce mock verilerinin ayarlandığından emin olur.

beforeAll ayrıca isteğe bağlı bir temizleme fonksiyonu da kabul eder (afterAll ile eşdeğerdir).

import { beforeAll } from 'vitest';

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

  // temizleme fonksiyonu, tüm testler çalıştırıldıktan sonra bir kez çağrılır
  return async () => {
    await stopMocking();
  };
});

afterAll

Tür: afterAll(fn: () => Awaitable<void>, timeout?: number)

Mevcut bağlamdaki tüm testler çalıştırıldıktan sonra bir kez çağrılacak bir geri arama fonksiyonu kaydeder. 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 belirten bir zaman aşımı (milisaniye cinsinden) sağlayabilirsiniz. Varsayılan 5 saniyedir.

import { afterAll } from 'vitest';

afterAll(async () => {
  await stopMocking(); // bu yöntem tüm testler çalıştırıldıktan sonra çağrılır
});

Burada afterAll, tüm testler çalıştırıldıktan sonra stopMocking yönteminin çağrıldığından emin olur.

Test Kancaları

Vitest, test yürütmesi sırasında, test tamamlandıktan sonra durumu temizlemek için çağırabileceğiniz birkaç kanca sağlar.

WARNING

Bu kancalar, test gövdesinin dışında çağrılırlarsa bir hata fırlatırlar.

onTestFinished

Bu kanca, test çalışmayı tamamladıktan sonra her zaman çağrılır. afterEach kancalarından sonra çağrılır, çünkü bunlar test sonucunu etkileyebilir. beforeEach ve afterEach gibi bir ExtendedContext nesnesi alır.

import { onTestFinished, test } from 'vitest';

test('bir sorgu gerçekleştirir', () => {
  const db = connectDb();
  onTestFinished(() => db.close());
  db.query('SELECT * FROM users');
});

WARNING

Testleri eşzamanlı olarak çalıştırıyorsanız, Vitest global kancalarda eşzamanlı testleri izlemediği için onTestFinished kancasını her zaman test bağlamından kullanmalısınız:

import { test } from 'vitest';

test.concurrent('bir sorgu gerçekleştirir', ({ 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('bir kullanıcı sorgusu gerçekleştirir', async () => {
  const db = getTestDb();
  expect(await db.query('SELECT * from users').perform()).toEqual([]);
});

test('bir organizasyon sorgusu gerçekleştirir', 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. afterEach kancalarından sonra çağrılır, çünkü bunlar test sonucunu etkileyebilir. beforeEach ve afterEach gibi bir ExtendedContext nesnesi alır. Bu kanca hata ayıklama için kullanışlıdır.

import { onTestFailed, test } from 'vitest';

test('bir sorgu gerçekleştirir', () => {
  const db = connectDb();
  onTestFailed(({ task }) => {
    console.log(task.result.errors);
  });
  db.query('SELECT * FROM users');
});

WARNING

Testleri eşzamanlı olarak çalıştırıyorsanız, Vitest global kancalarda eşzamanlı testleri izlemediği için onTestFailed kancasını her zaman test bağlamından kullanmalısınız:

import { test } from 'vitest';

test.concurrent('bir sorgu gerçekleştirir', ({ onTestFailed }) => {
  const db = connectDb();
  onTestFailed(({ task }) => {
    console.log(task.result.errors);
  });
  db.query('SELECT * FROM users');
});

Test API Referansları ​

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 ​

describe.for ​

Kurulum ve Yıkım ​

beforeEach ​

afterEach ​

beforeAll ​

afterAll ​

Test Kancaları ​

onTestFinished ​

onTestFailed ​

Test API Referansları

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

describe.for

Kurulum ve Yıkım

beforeEach

afterEach

beforeAll

afterAll

Test Kancaları

onTestFinished

onTestFailed