expect

Aşağıdaki tür imzalarında kullanılan türler şunlardır:

type Awaitable<T> = T | PromiseLike<T>;

expect, iddialar (assertions) oluşturmak için kullanılır. Bu bağlamda iddialar, bir ifadenin doğruluğunu onaylamak için çağrılabilen fonksiyonlardır. Vitest, varsayılan olarak chai iddialarını ve ayrıca chai üzerine inşa edilmiş Jest uyumlu iddiaları sağlar. Jest'in aksine, Vitest ikinci argüman olarak bir mesajı destekler; eğer iddia başarısız olursa, hata mesajı bu belirtilen mesajla aynı olacaktır.

export interface ExpectStatic
  extends Chai.ExpectStatic,
    AsymmetricMatchersContaining {
  <T>(actual: T, message?: string): Assertion<T>;
  extend: (expects: MatchersObject) => void;
  anything: () => any;
  any: (constructor: unknown) => any;
  getState: () => MatcherState;
  setState: (state: Partial<MatcherState>) => void;
  not: AsymmetricMatchersContaining;
}

Örneğin, bu kod bir input değerinin 2'ye eşit olduğunu iddia eder. Eğer eşit değilse, iddia bir hata fırlatır ve test başarısız olur.

import { expect } from 'vitest';

const input = Math.sqrt(4);

expect(input).to.equal(2); // chai API
expect(input).toBe(2); // jest API

Bu örnek teknik olarak test fonksiyonunu kullanmaz, bu yüzden konsolda Vitest çıktısı yerine Node.js hatası göreceksiniz. test hakkında daha fazla bilgi edinmek için lütfen Test API Referansı bölümünü okuyun.

Ayrıca, expect daha sonra açıklanan eşleştirici fonksiyonlara ve diğerlerine erişmek için statik olarak kullanılabilir.

WARNING

expect, ifade bir tür hatası içermiyorsa, test türleri üzerinde hiçbir etkisi yoktur. Vitest'i tür denetleyicisi olarak kullanmak istiyorsanız, expectTypeOf veya assertType kullanın.

soft

• Tür: ExpectStatic & (actual: any) => Assertions

expect.soft fonksiyonu expect'e benzer şekilde çalışır, ancak başarısız bir iddia durumunda test yürütmesini sonlandırmak yerine, çalışmaya devam eder ve hatayı bir test hatası olarak işaretler. Test sırasında karşılaşılan tüm hatalar test tamamlanana kadar görüntülenecektir.

import { expect, test } from 'vitest';

test('expect.soft test', () => {
  expect.soft(1 + 1).toBe(3); // testi başarısız olarak işaretler ve devam eder
  expect.soft(1 + 2).toBe(4); // testi başarısız olarak işaretler ve devam eder
});
// raporlayıcı, çalıştırmanın sonunda her iki hatayı da raporlayacaktır

expect ile de kullanılabilir. Eğer expect iddiası başarısız olursa, test sonlandırılır ve önceki tüm hatalar çıktı olarak verilir.

import { expect, test } from 'vitest';

test('expect.soft test', () => {
  expect.soft(1 + 1).toBe(3); // testi başarısız olarak işaretler ve devam eder
  expect(1 + 2).toBe(4); // başarısız olur ve testi sonlandırır, önceki tüm hatalar çıktı olarak verilir
  expect.soft(1 + 3).toBe(5); // çalıştırılmaz
});

WARNING

expect.soft yalnızca test fonksiyonunun içinde kullanılabilir.

poll

interface ExpectPoll extends ExpectStatic {
  (actual: () => T, options: { interval; timeout; message }): Promise<
    Assertions<T>
  >;
}

expect.poll, iddia başarılı olana kadar tekrar çalıştırılır. interval ve timeout seçeneklerini ayarlayarak Vitest'in expect.poll geri çağrısını kaç kez yeniden çalıştırması gerektiğini yapılandırabilirsiniz.

expect.poll geri çağrısı içinde bir hata fırlatılırsa, Vitest zaman aşımı süresi dolana kadar tekrar deneyecektir.

import { expect, test } from 'vitest';

test('element exists', async () => {
  asyncInjectElement();

  await expect.poll(() => document.querySelector('.element')).toBeTruthy();
});

WARNING

expect.poll her iddiayı eşzamansız hale getirir, bu yüzden onu await etmeniz gerekir. Vitest 3'ten beri, eğer await etmeyi unutursanız, test bir uyarı ile başarısız olacaktır.

expect.poll bazı eşleştiricilerle çalışmaz:

• Anlık görüntü eşleştiricileri desteklenmez çünkü her zaman başarılı olurlar. Eğer koşulunuz kararsızsa, önce onu çözmek için vi.waitFor kullanmayı düşünebilirsiniz:

import { expect, vi } from 'vitest';

const flakyValue = await vi.waitFor(() => getFlakyValue());
expect(flakyValue).toMatchSnapshot();

• .resolves ve .rejects desteklenmez. expect.poll zaten koşul eşzamansızsa onu bekler.
• toThrow ve takma adları desteklenmez çünkü expect.poll koşulu, eşleştirici değeri almadan önce her zaman çözülür.

not

not kullanmak iddiayı olumsuzlar. Örneğin, bu kod bir input değerinin 2'ye eşit olmadığını iddia eder. Eğer eşitse, iddia bir hata fırlatır ve test başarısız olur.

import { expect, test } from 'vitest';

const input = Math.sqrt(16);

expect(input).not.to.equal(2); // chai API
expect(input).not.toBe(2); // jest API

toBe

• Tür: (value: any) => Awaitable<void>

toBe, ilkel değerlerin eşit olup olmadığını veya nesnelerin aynı referansı paylaşıp paylaşmadığını iddia etmek için kullanılabilir. Bu, expect(Object.is(3, 3)).toBe(true) çağırmakla eşdeğerdir. Eğer nesneler aynı değilse, ancak yapısal olarak aynı olup olmadıklarını kontrol etmek istiyorsanız, toEqual kullanabilirsiniz.

Örneğin, aşağıdaki kod tüccarın 13 elması olup olmadığını kontrol eder.

import { expect, test } from 'vitest';

const stock = {
  type: 'apples',
  count: 13,
};

test('stokta 13 elma var', () => {
  expect(stock.type).toBe('apples');
  expect(stock.count).toBe(13);
});

test('stoklar aynıdır', () => {
  const refStock = stock; // aynı referans

  expect(stock).toBe(refStock);
});

Kayan noktalı sayılarla toBe kullanmamaya çalışın. JavaScript onları yuvarladığı için, 0.1 + 0.2 kesinlikle 0.3 değildir. Kayan noktalı sayıları güvenilir bir şekilde iddia etmek için toBeCloseTo iddiasını kullanın.

toBeCloseTo

• Tür: (value: number, numDigits?: number) => Awaitable<void>

Kayan noktalı sayıları karşılaştırmak için toBeCloseTo kullanın. İsteğe bağlı numDigits argümanı, ondalık noktadan sonra kontrol edilecek basamak sayısını sınırlar. Örneğin:

import { expect, test } from 'vitest';

test.fails('JavaScript\'te ondalık sayılar eşit değildir', () => {
  expect(0.2 + 0.1).toBe(0.3); // 0.2 + 0.1, 0.30000000000000004'tür
});

test('ondalık sayılar noktadan sonra 5\'e yuvarlanır', () => {
  // 0.2 + 0.1, 0.30000'dır | "000000000004" kaldırıldı
  expect(0.2 + 0.1).toBeCloseTo(0.3, 5);
  // 0.30000000000000004'ten hiçbir şey kaldırılmaz
  expect(0.2 + 0.1).not.toBeCloseTo(0.3, 50);
});

toBeDefined

• Tür: () => Awaitable<void>

toBeDefined, değerin undefined'a eşit olmadığını iddia eder. Fonksiyonun bir şey döndürüp döndürmediğini kontrol etmek için kullanışlıdır.

import { expect, test } from 'vitest';

function getApples() {
  return 3;
}

test('fonksiyon bir şey döndürdü', () => {
  expect(getApples()).toBeDefined();
});

toBeUndefined

• Tür: () => Awaitable<void>

toBeDefined'ın tersi olan toBeUndefined, değerin undefined'a eşit olduğunu iddia eder. Fonksiyonun bir şey döndürmediğini kontrol etmek için kullanışlıdır.

import { expect, test } from 'vitest';

function getApplesFromStock(stock: string) {
  if (stock === 'Bill') {
    return 13;
  }
}

test("Mary'nin stoğu yok", () => {
  expect(getApplesFromStock('Mary')).toBeUndefined();
});

toBeTruthy

• Tür: () => Awaitable<void>

toBeTruthy, değerin boole'a dönüştürüldüğünde true olduğunu iddia eder. Değerle ilgilenmiyorsanız, ancak sadece true'ya dönüştürülebileceğini bilmek istiyorsanız kullanışlıdır.

Örneğin, bu kodla stocks.getInfo'nun dönüş değeriyle ilgilenmiyorsunuz - karmaşık bir nesne, bir dize veya başka bir şey olabilir. Kod yine de çalışacaktır.

import { Stocks } from './stocks.js';

const stocks = new Stocks();
stocks.sync('Bill');
if (stocks.getInfo('Bill')) {
  stocks.sell('apples', 'Bill');
}

Bu yüzden stocks.getInfo'nun truthy olacağını test etmek isterseniz, şöyle yazabilirsiniz:

import { expect, test } from 'vitest';
import { Stocks } from './stocks.js';

const stocks = new Stocks();

test('Bill stoğunu biliyorsak, ona elma sat', () => {
  stocks.sync('Bill');
  expect(stocks.getInfo('Bill')).toBeTruthy();
});

JavaScript'teki her şey doğru (truthy) değerdir, false, null, undefined, NaN, 0, -0, 0n, "" ve document.all hariç.

toBeFalsy

• Tür: () => Awaitable<void>

toBeFalsy, değerin boole'a dönüştürüldüğünde false olduğunu iddia eder. Değerle ilgilenmiyorsanız, ancak sadece false'a dönüştürülebileceğini bilmek istiyorsanız kullanışlıdır.

Örneğin, bu kodla stocks.stockFailed'ın dönüş değeriyle ilgilenmiyorsunuz - herhangi bir yanlış (falsy) değer döndürebilir, ancak kod yine de çalışacaktır.

import { Stocks } from './stocks.js';

const stocks = new Stocks();
stocks.sync('Bill');
if (!stocks.stockFailed('Bill')) {
  stocks.sell('apples', 'Bill');
}

Bu yüzden stocks.stockFailed'ın falsy olacağını test etmek isterseniz, şöyle yazabilirsiniz:

import { expect, test } from 'vitest';
import { Stocks } from './stocks.js';

const stocks = new Stocks();

test('Bill stoğu başarısız olmadıysa, ona elma sat', () => {
  stocks.syncStocks('Bill');
  expect(stocks.stockFailed('Bill')).toBeFalsy();
});

JavaScript'teki her şey doğru (truthy) değerdir, false, null, undefined, NaN, 0, -0, 0n, "" ve document.all hariç.

toBeNull

• Tür: () => Awaitable<void>

toBeNull basitçe bir şeyin null olup olmadığını iddia eder. .toBe(null) için bir takma addır.

import { expect, test } from 'vitest';

function apples() {
  return null;
}

test('elmamız yok', () => {
  expect(apples()).toBeNull();
});

toBeNaN

• Tür: () => Awaitable<void>

toBeNaN basitçe bir şeyin NaN olup olmadığını iddia eder. .toBe(NaN) için bir takma addır.

import { expect, test } from 'vitest';

let i = 0;

function getApplesCount() {
  i++;
  return i > 1 ? Number.NaN : i;
}

test('getApplesCount bazı alışılmadık yan etkilere sahiptir...', () => {
  expect(getApplesCount()).not.toBeNaN();
  expect(getApplesCount()).toBeNaN();
});

toBeOneOf

• Tür: (sample: Array<any>) => any

toBeOneOf, bir değerin sağlanan dizideki değerlerden herhangi biriyle eşleşip eşleşmediğini iddia eder.

import { expect, test } from 'vitest';

test('meyve izin verilen değerlerden biri', () => {
  expect(fruit).toBeOneOf(['elma', 'muz', 'portakal']);
});

Asimetrik eşleştirici, özellikle null veya undefined olabilecek isteğe bağlı özellikleri test ederken kullanışlıdır:

test('isteğe bağlı özellikler null veya undefined olabilir', () => {
  const user = {
    firstName: 'John',
    middleName: undefined,
    lastName: 'Doe',
  };

  expect(user).toEqual({
    firstName: expect.any(String),
    middleName: expect.toBeOneOf([expect.any(String), undefined]),
    lastName: expect.any(String),
  });
});

TIP

Bir değerin sağlanan seçeneklerden herhangi biriyle eşleşmediğinden emin olmak için bu eşleştiriciyle expect.not kullanabilirsiniz.

toBeTypeOf

• Tür: (c: 'bigint' | 'boolean' | 'function' | 'number' | 'object' | 'string' | 'symbol' | 'undefined') => Awaitable<void>

toBeTypeOf, gerçek bir değerin alınan türde olup olmadığını iddia eder.

import { expect, test } from 'vitest';

const actual = 'stock';

test('stok string türünde', () => {
  expect(actual).toBeTypeOf('string');
});

toBeInstanceOf

• Tür: (c: any) => Awaitable<void>

toBeInstanceOf, gerçek bir değerin alınan sınıfın bir örneği olup olmadığını iddia eder.

import { expect, test } from 'vitest';
import { Stocks } from './stocks.js';

const stocks = new Stocks();

test('stoklar Stocks örneği', () => {
  expect(stocks).toBeInstanceOf(Stocks);
});

toBeGreaterThan

• Tür: (n: number | bigint) => Awaitable<void>

toBeGreaterThan, gerçek değerin alınan değerden büyük olup olmadığını iddia eder. Eşit değerler testi başarısız kılar.

import { expect, test } from 'vitest';
import { getApples } from './stocks.js';

test('10 elmadan fazla var', () => {
  expect(getApples()).toBeGreaterThan(10);
});

toBeGreaterThanOrEqual

• Tür: (n: number | bigint) => Awaitable<void>

toBeGreaterThanOrEqual, gerçek değerin alınan değerden büyük veya ona eşit olup olmadığını iddia eder.

import { expect, test } from 'vitest';
import { getApples } from './stocks.js';

test('11 elma veya daha fazla var', () => {
  expect(getApples()).toBeGreaterThanOrEqual(11);
});

toBeLessThan

• Tür: (n: number | bigint) => Awaitable<void>

toBeLessThan, gerçek değerin alınan değerden küçük olup olmadığını iddia eder. Eşit değerler testi başarısız kılar.

import { expect, test } from 'vitest';
import { getApples } from './stocks.js';

test('20 elmadan az var', () => {
  expect(getApples()).toBeLessThan(20);
});

toBeLessThanOrEqual

• Tür: (n: number | bigint) => Awaitable<void>

toBeLessThanOrEqual, gerçek değerin alınan değerden küçük veya ona eşit olup olmadığını iddia eder.

import { expect, test } from 'vitest';
import { getApples } from './stocks.js';

test('11 elma veya daha az var', () => {
  expect(getApples()).toBeLessThanOrEqual(11);
});

toEqual

• Tür: (received: any) => Awaitable<void>

toEqual, gerçek değerin alınan değere eşit olup olmadığını veya bir nesne ise aynı yapıya sahip olup olmadığını (özyinelemeli olarak karşılaştırır) iddia eder. toEqual ve toBe arasındaki farkı bu örnekte görebilirsiniz:

import { expect, test } from 'vitest';

const stockBill = {
  type: 'apples',
  count: 13,
};

const stockMary = {
  type: 'apples',
  count: 13,
};

test('stoklar aynı özelliklere sahip', () => {
  expect(stockBill).toEqual(stockMary);
});

test('stoklar aynı değil', () => {
  expect(stockBill).not.toBe(stockMary);
});

WARNING

Error nesneleri için, name, message, cause ve AggregateError.errors gibi numaralandırılamayan özellikler de karşılaştırılır. Error.cause için karşılaştırma asimetrik olarak yapılır:

// başarı
expect(new Error('hi', { cause: 'x' })).toEqual(new Error('hi'));

// başarısız
expect(new Error('hi')).toEqual(new Error('hi', { cause: 'x' }));

Bir şeyin fırlatılıp fırlatılmadığını test etmek için toThrowError iddiasını kullanın.

toStrictEqual

• Tür: (received: any) => Awaitable<void>

toStrictEqual, gerçek değerin alınan değere eşit olup olmadığını veya bir nesne ise aynı yapıya sahip olup olmadığını (özyinelemeli olarak karşılaştırır) ve aynı türde olup olmadığını iddia eder.

.toEqual'dan farkları:

• undefined özelliklere sahip anahtarlar kontrol edilir. Örneğin, {a: undefined, b: 2}, .toStrictEqual kullanıldığında {b: 2} ile eşleşmez.
• Dizi seyrekliği kontrol edilir. Örneğin, [, 1], .toStrictEqual kullanıldığında [undefined, 1] ile eşleşmez.
• Nesne türlerinin eşit olduğu kontrol edilir. Örneğin, a ve b alanlarına sahip bir sınıf örneği, a ve b alanlarına sahip bir literal nesneye eşit olmayacaktır.

import { expect, test } from 'vitest';

class Stock {
  constructor(type) {
    this.type = type;
  }
}

test('yapısal olarak aynı, ancak anlamsal olarak farklı', () => {
  expect(new Stock('apples')).toEqual({ type: 'apples' });
  expect(new Stock('apples')).not.toStrictEqual({ type: 'apples' });
});

toContain

• Tür: (received: string) => Awaitable<void>

toContain, gerçek değerin bir dizide olup olmadığını iddia eder. toContain ayrıca bir dizenin başka bir dizenin alt dizesi olup olmadığını da kontrol edebilir. Tarayıcı benzeri bir ortamda testler çalıştırıyorsanız, bu iddia bir sınıfın classList içinde olup olmadığını veya bir öğenin başka bir öğenin içinde olup olmadığını da kontrol edebilir.

import { expect, test } from 'vitest';
import { getAllFruits } from './stocks.js';

test('meyve listesi portakal içeriyor', () => {
  expect(getAllFruits()).toContain('orange');

  const element = document.querySelector('#el');
  // elementin bir sınıfı var
  expect(element.classList).toContain('flex');
  // element başka bir elementin içinde
  expect(document.querySelector('#wrapper')).toContain(element);
});

toContainEqual

• Tür: (received: any) => Awaitable<void>

toContainEqual, belirli bir yapıya ve değerlere sahip bir öğenin bir dizide bulunup bulunmadığını iddia eder. Her öğe için toEqual gibi çalışır.

import { expect, test } from 'vitest';
import { getFruitStock } from './stocks.js';

test('elma mevcut', () => {
  expect(getFruitStock()).toContainEqual({ fruit: 'apple', count: 5 });
});

toHaveLength

• Tür: (received: number) => Awaitable<void>

toHaveLength, bir nesnenin .length özelliğine sahip olup olmadığını ve belirli bir sayısal değere ayarlanıp ayarlanmadığını iddia eder.

import { expect, test } from 'vitest';

test('toHaveLength', () => {
  expect('abc').toHaveLength(3);
  expect([1, 2, 3]).toHaveLength(3);

  expect('').not.toHaveLength(3); // .length özelliği 3 değildir
  expect({ length: 3 }).toHaveLength(3);
});

toHaveProperty

• Tür: (key: any, received?: any) => Awaitable<void>

toHaveProperty, sağlanan referans key'de bir özelliğin bir nesne için var olup olmadığını iddia eder.

İsteğe bağlı bir değer argümanı da sağlayabilirsiniz; bu argüman derin eşitlik olarak da bilinir ve alınan özellik değerini karşılaştırmak için toEqual eşleştiricisi gibi çalışır.

import { expect, test } from 'vitest';

const invoice = {
  isActive: true,
  'P.O': '12345',
  customer: {
    first_name: 'John',
    last_name: 'Doe',
    location: 'China',
  },
  total_amount: 5000,
  items: [
    {
      type: 'apples',
      quantity: 10,
    },
    {
      type: 'oranges',
      quantity: 5,
    },
  ],
};

test('John Doe Faturası', () => {
  expect(invoice).toHaveProperty('isActive'); // anahtarın var olduğunu iddia et
  expect(invoice).toHaveProperty('total_amount', 5000); // anahtarın var olduğunu ve değerin eşit olduğunu iddia et

  expect(invoice).not.toHaveProperty('account'); // bu anahtarın var olmadığını iddia et

  // Nokta gösterimi kullanarak derin referanslama
  expect(invoice).toHaveProperty('customer.first_name');
  expect(invoice).toHaveProperty('customer.last_name', 'Doe');
  expect(invoice).not.toHaveProperty('customer.location', 'India');

  // Anahtarı içeren bir dizi kullanarak derin referanslama
  expect(invoice).toHaveProperty('items[0].type', 'apples');
  expect(invoice).toHaveProperty('items.0.type', 'apples'); // nokta gösterimi de çalışır

  // Anahtar yolunu içeren bir dizi kullanarak derin referanslama
  expect(invoice).toHaveProperty(['items', 0, 'type'], 'apples');
  expect(invoice).toHaveProperty(['items', '0', 'type'], 'apples'); // string gösterimi de çalışır

  // Anahtarın derin referans olarak ayrıştırılmasını önlemek için anahtarınızı bir diziye sarın
  expect(invoice).toHaveProperty(['P.O'], '12345');
});

toMatch

• Tür: (received: string | regexp) => Awaitable<void>

toMatch, bir dizenin bir düzenli ifadeyle veya bir dizeyle eşleşip eşleşmediğini iddia eder.

import { expect, test } from 'vitest';

test('en iyi meyveler', () => {
  expect('top fruits include apple, orange and grape').toMatch(/apple/);
  expect('applefruits').toMatch('fruit'); // toMatch ayrıca bir dize de kabul eder
});

toMatchObject

• Tür: (received: object | array) => Awaitable<void>

toMatchObject, bir nesnenin bir nesnenin özelliklerinin bir alt kümesiyle eşleşip eşleşmediğini iddia eder.

Nesnelerden oluşan bir dizi de geçirebilirsiniz. Bu, iki dizinin öğe sayılarında eşleştiğini kontrol etmek istediğinizde kullanışlıdır; arrayContaining'in aksine, bu eşleştirici alınan dizide fazladan öğelere izin verir.

import { expect, test } from 'vitest';

const johnInvoice = {
  isActive: true,
  customer: {
    first_name: 'John',
    last_name: 'Doe',
    location: 'China',
  },
  total_amount: 5000,
  items: [
    {
      type: 'apples',
      quantity: 10,
    },
    {
      type: 'oranges',
      quantity: 5,
    },
  ],
};

const johnDetails = {
  customer: {
    first_name: 'John',
    last_name: 'Doe',
    location: 'China',
  },
};

test('faturada John\'un kişisel bilgileri var', () => {
  expect(johnInvoice).toMatchObject(johnDetails);
});

test('eleman sayısı tam olarak eşleşmeli', () => {
  // Nesnelerden oluşan bir dizinin eşleştiğini iddia et
  expect([{ foo: 'bar' }, { baz: 1 }]).toMatchObject([
    { foo: 'bar' },
    { baz: 1 },
  ]);
});

toThrowError

• Tür: (received: any) => Awaitable<void>

• Takma Ad: toThrow

toThrowError, bir fonksiyon çağrıldığında bir hata fırlatıp fırlatmadığını iddia eder.

Belirli bir hatanın fırlatıldığını test etmek için isteğe bağlı bir argüman sağlayabilirsiniz:

• RegExp: hata mesajı deseni eşleşir
• string: hata mesajı alt dizeyi içerir
• Error, AsymmetricMatcher: toEqual(received)'a benzer şekilde alınan bir nesneyle karşılaştırın

TIP

Kodu bir fonksiyona sarmalısınız, aksi takdirde hata yakalanmaz ve test başarısız olur.

Bu, rejects promise'ı doğru şekilde işlediği için eşzamansız çağrılar için geçerli değildir:

test('expect rejects toThrow', async ({ expect }) => {
  const promise = Promise.reject(new Error('Test'));
  await expect(promise).rejects.toThrowError();
});

Örneğin, getFruitStock('pineapples')'ın hata fırlattığını test etmek istersek, şöyle yazabiliriz:

import { expect, test } from 'vitest';

function getFruitStock(type: string) {
  if (type === 'pineapples') {
    throw new Error('Pineapples are not in stock');
  }

  // Başka şeyler yap
}

test('ananaslarda hata fırlatır', () => {
  // Hata mesajının bir yerinde "stock" yazdığını test et: bunlar eşdeğerdir
  expect(() => getFruitStock('pineapples')).toThrowError(/stock/);
  expect(() => getFruitStock('pineapples')).toThrowError('stock');

  // Tam hata mesajını test et
  expect(() => getFruitStock('pineapples')).toThrowError(
    /^Pineapples are not in stock$/
  );

  expect(() => getFruitStock('pineapples')).toThrowError(
    new Error('Pineapples are not in stock')
  );
  expect(() => getFruitStock('pineapples')).toThrowError(
    expect.objectContaining({
      message: 'Pineapples are not in stock',
    })
  );
});

TIP

Eşzamansız fonksiyonları test etmek için rejects ile birlikte kullanın.

function getAsyncFruitStock() {
  return Promise.reject(new Error('empty'));
}

test('ananaslarda hata fırlatır', async () => {
  await expect(() => getAsyncFruitStock()).rejects.toThrowError('empty');
});

toMatchSnapshot

• Tür: <T>(shape?: Partial<T> | string, hint?: string) => void

Bu, bir değerin en son anlık görüntüyle eşleştiğini garanti eder.

Test adına eklenen isteğe bağlı bir hint dize argümanı sağlayabilirsiniz. Vitest her zaman bir anlık görüntü adının sonuna bir sayı eklese de, kısa açıklayıcı ipuçları, tek bir it veya test bloğundaki birden çok anlık görüntüyü ayırt etmek için sayılardan daha kullanışlı olabilir. Vitest, karşılık gelen .snap dosyasındaki anlık görüntüleri ada göre sıralar.

TIP

Bir anlık görüntü eşleşmediğinde ve testin başarısız olmasına neden olduğunda, eğer eşleşmeme bekleniyorsa, anlık görüntüyü bir kez güncellemek için u tuşuna basabilirsiniz. Veya Vitest'in testleri her zaman güncellemesini sağlamak için -u veya --update CLI seçeneklerini geçirebilirsiniz.

import { expect, test } from 'vitest';

test('anlık görüntüyle eşleşiyor', () => {
  const data = { foo: new Set(['bar', 'snapshot']) };
  expect(data).toMatchSnapshot();
});

Bir nesnenin sadece şeklini test ediyorsanız ve %100 uyumlu olmasına gerek yoksa, bir nesnenin şeklini de sağlayabilirsiniz:

import { expect, test } from 'vitest';

test('anlık görüntüyle eşleşiyor', () => {
  const data = { foo: new Set(['bar', 'snapshot']) };
  expect(data).toMatchSnapshot({ foo: expect.any(Set) });
});

toMatchInlineSnapshot

• Tür: <T>(shape?: Partial<T> | string, snapshot?: string, hint?: string) => void

Bu, bir değerin en son anlık görüntüyle eşleştiğini garanti eder.

Vitest, test dosyasındaki eşleştiriciye (harici bir .snap dosyası yerine) inlineSnapshot dize argümanını ekler ve günceller.

import { expect, test } from 'vitest';

test('satır içi anlık görüntüyle eşleşiyor', () => {
  const data = { foo: new Set(['bar', 'snapshot']) };
  // Vitest, anlık görüntüyü güncellerken aşağıdaki içeriği güncelleyecektir
  expect(data).toMatchInlineSnapshot(`
    {
      "foo": Set {
        "bar",
        "snapshot",
      },
    }
  `);
});

Bir nesnenin sadece şeklini test ediyorsanız ve %100 uyumlu olmasına gerek yoksa, bir nesnenin şeklini de sağlayabilirsiniz:

import { expect, test } from 'vitest';

test('anlık görüntüyle eşleşiyor', () => {
  const data = { foo: new Set(['bar', 'snapshot']) };
  expect(data).toMatchInlineSnapshot(
    { foo: expect.any(Set) },
    `
    {
      "foo": Any<Set>,
    }
  `
  );
});

toMatchFileSnapshot

• Tür: <T>(filepath: string, hint?: string) => Promise<void>

Anlık görüntüyü açıkça belirtilen bir dosyanın içeriğiyle karşılaştırın veya güncelleyin ( .snap dosyası yerine).

import { expect, it } from 'vitest';

it('temel render', async () => {
  const result = renderHTML(h('div', { class: 'foo' }));
  await expect(result).toMatchFileSnapshot('./test/basic.output.html');
});

Dosya sistemi işlemleri eşzamansız olduğundan, toMatchFileSnapshot() ile await kullanmanız gerektiğini unutmayın. Eğer await kullanılmazsa, Vitest bunu expect.soft gibi ele alır, yani ifadeden sonraki kod, anlık görüntü eşleşmese bile çalışmaya devam edecektir. Test bittikten sonra, Vitest anlık görüntüyü kontrol edecek ve bir eşleşmeme varsa başarısız olacaktır.

toThrowErrorMatchingSnapshot

• Tür: (hint?: string) => void

toMatchSnapshot ile aynı, ancak toThrowError ile aynı değeri bekler.

toThrowErrorMatchingInlineSnapshot

• Tür: (snapshot?: string, hint?: string) => void

toMatchInlineSnapshot ile aynı, ancak toThrowError ile aynı değeri bekler.

toHaveBeenCalled

• Tür: () => Awaitable<void>

Bu iddia, bir fonksiyonun çağrılıp çağrılmadığını test etmek için kullanışlıdır. expect'e bir casus fonksiyonu geçirilmesi gerekir.

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

const market = {
  buy(subject: string, amount: number) {
    // ...
  },
};

test('casus fonksiyonu', () => {
  const buySpy = vi.spyOn(market, 'buy');

  expect(buySpy).not.toHaveBeenCalled();

  market.buy('apples', 10);

  expect(buySpy).toHaveBeenCalled();
});

toHaveBeenCalledTimes

• Tür: (amount: number) => Awaitable<void>

Bu iddia, bir fonksiyonun belirli sayıda çağrılıp çağrılmadığını kontrol eder. expect'e bir casus fonksiyonu geçirilmesi gerekir.

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

const market = {
  buy(subject: string, amount: number) {
    // ...
  },
};

test('casus fonksiyonu iki kez çağrıldı', () => {
  const buySpy = vi.spyOn(market, 'buy');

  market.buy('apples', 10);
  market.buy('apples', 20);

  expect(buySpy).toHaveBeenCalledTimes(2);
});

toHaveBeenCalledWith

• Tür: (...args: any[]) => Awaitable<void>

Bu iddia, bir fonksiyonun belirli parametrelerle en az bir kez çağrılıp çağrılmadığını kontrol eder. expect'e bir casus fonksiyonu geçirilmesi gerekir.

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

const market = {
  buy(subject: string, amount: number) {
    // ...
  },
};

test('casus fonksiyonu', () => {
  const buySpy = vi.spyOn(market, 'buy');

  market.buy('apples', 10);
  market.buy('apples', 20);

  expect(buySpy).toHaveBeenCalledWith('apples', 10);
  expect(buySpy).toHaveBeenCalledWith('apples', 20);
});

toHaveBeenCalledBefore 3.0.0+

• Tür: (mock: MockInstance, failIfNoFirstInvocation?: boolean) => Awaitable<void>

Bu iddia, bir Mock'un başka bir Mock'tan önce çağrılıp çağrılmadığını kontrol eder.

test('mock1, mock2\'den önce çağrılır', () => {
  const mock1 = vi.fn();
  const mock2 = vi.fn();

  mock1();
  mock2();
  mock1();

  expect(mock1).toHaveBeenCalledBefore(mock2);
});

toHaveBeenCalledAfter 3.0.0+

• Tür: (mock: MockInstance, failIfNoFirstInvocation?: boolean) => Awaitable<void>

Bu iddia, bir Mock'un başka bir Mock'tan sonra çağrılıp çağrılmadığını kontrol eder.

test('mock1, mock2\'den sonra çağrılır', () => {
  const mock1 = vi.fn();
  const mock2 = vi.fn();

  mock2();
  mock1();
  mock2();

  expect(mock1).toHaveBeenCalledAfter(mock2);
});

toHaveBeenCalledExactlyOnceWith 3.0.0+

• Tür: (...args: any[]) => Awaitable<void>

Bu iddia, bir fonksiyonun yalnızca bir kez ve belirli parametrelerle çağrılıp çağrılmadığını kontrol eder. expect'e bir casus fonksiyonu geçirilmesi gerekir.

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

const market = {
  buy(subject: string, amount: number) {
    // ...
  },
};

test('casus fonksiyonu', () => {
  const buySpy = vi.spyOn(market, 'buy');

  market.buy('apples', 10);

  expect(buySpy).toHaveBeenCalledExactlyOnceWith('apples', 10);
});

toHaveBeenLastCalledWith

• Tür: (...args: any[]) => Awaitable<void>

Bu iddia, bir fonksiyonun son çağrısında belirli parametrelerle çağrılıp çağrılmadığını kontrol eder. expect'e bir casus fonksiyonu geçirilmesi gerekir.

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

const market = {
  buy(subject: string, amount: number) {
    // ...
  },
};

test('casus fonksiyonu', () => {
  const buySpy = vi.spyOn(market, 'buy');

  market.buy('apples', 10);
  market.buy('apples', 20);

  expect(buySpy).not.toHaveBeenLastCalledWith('apples', 10);
  expect(buySpy).toHaveBeenLastCalledWith('apples', 20);
});

toHaveBeenNthCalledWith

• Tür: (time: number, ...args: any[]) => Awaitable<void>

Bu iddia, bir fonksiyonun belirli bir zamanda belirli parametrelerle çağrılıp çağrılmadığını kontrol eder. Sayım 1'den başlar. Yani, ikinci çağrıyı kontrol etmek için .toHaveBeenNthCalledWith(2, ...) yazarsınız.

expect'e bir casus fonksiyonu geçirilmesi gerekir.

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

const market = {
  buy(subject: string, amount: number) {
    // ...
  },
};

test('casus fonksiyonunun ilk çağrısı doğru parametrelerle çağrıldı', () => {
  const buySpy = vi.spyOn(market, 'buy');

  market.buy('apples', 10);
  market.buy('apples', 20);

  expect(buySpy).toHaveBeenNthCalledWith(1, 'apples', 10);
});

toHaveReturned

• Tür: () => Awaitable<void>

Bu iddia, bir fonksiyonun en az bir kez başarılı bir şekilde bir değer döndürdüğünü (yani, bir hata fırlatmadığını) kontrol eder. expect'e bir casus fonksiyonu geçirilmesi gerekir.

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

function getApplesPrice(amount: number) {
  const PRICE = 10;
  return amount * PRICE;
}

test('casus fonksiyonu bir değer döndürdü', () => {
  const getPriceSpy = vi.fn(getApplesPrice);

  const price = getPriceSpy(10);

  expect(price).toBe(100);
  expect(getPriceSpy).toHaveReturned();
});

toHaveReturnedTimes

• Tür: (amount: number) => Awaitable<void>

Bu iddia, bir fonksiyonun belirli bir sayıda başarılı bir şekilde bir değer döndürdüğünü (yani, bir hata fırlatmadığını) kontrol eder. expect'e bir casus fonksiyonu geçirilmesi gerekir.

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

test('casus fonksiyonu iki kez değer döndürür', () => {
  const sell = vi.fn((product: string) => ({ product }));

  sell('apples');
  sell('bananas');

  expect(sell).toHaveReturnedTimes(2);
});

toHaveReturnedWith

• Tür: (returnValue: any) => Awaitable<void>

Bu iddiayı, bir fonksiyonun belirli parametrelerle en az bir kez başarılı bir şekilde bir değer döndürdüğünü kontrol etmek için çağırabilirsiniz. expect'e bir casus fonksiyonu geçirilmesi gerekir.

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

test('casus fonksiyonu bir ürün döndürür', () => {
  const sell = vi.fn((product: string) => ({ product }));

  sell('apples');

  expect(sell).toHaveReturnedWith({ product: 'apples' });
});

toHaveLastReturnedWith

• Tür: (returnValue: any) => Awaitable<void>

Bu iddiayı, bir fonksiyonun son çağrıldığında belirli bir değeri başarılı bir şekilde döndürdüğünü kontrol etmek için çağırabilirsiniz. expect'e bir casus fonksiyonu geçirilmesi gerekir.

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

test('casus fonksiyonu son çağrıda muz döndürür', () => {
  const sell = vi.fn((product: string) => ({ product }));

  sell('apples');
  sell('bananas');

  expect(sell).toHaveLastReturnedWith({ product: 'bananas' });
});

toHaveNthReturnedWith

• Tür: (time: number, returnValue: any) => Awaitable<void>

Bu iddiayı, bir fonksiyonun belirli bir çağrıda belirli parametrelerle başarılı bir şekilde bir değer döndürdüğünü kontrol etmek için çağırabilirsiniz. expect'e bir casus fonksiyonu geçirilmesi gerekir.

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

test('casus fonksiyonu ikinci çağrıda muz döndürür', () => {
  const sell = vi.fn((product: string) => ({ product }));

  sell('apples');
  sell('bananas');

  expect(sell).toHaveNthReturnedWith(2, { product: 'bananas' });
});

toHaveResolved

• Tür: () => Awaitable<void>

Bu iddia, bir fonksiyonun en az bir kez başarılı bir şekilde bir değeri çözdüğünü (yani, reddetmediğini) kontrol eder. expect'e bir casus fonksiyonu geçirilmesi gerekir.

Eğer fonksiyon bir promise döndürdüyse, ancak henüz çözülmediyse, bu başarısız olacaktır.

import { expect, test, vi } from 'vitest';
import db from './db/apples.js';

async function getApplesPrice(amount: number) {
  return amount * (await db.get('price'));
}

test('casus fonksiyonu bir değeri çözdü', async () => {
  const getPriceSpy = vi.fn(getApplesPrice);

  const price = await getPriceSpy(10);

  expect(price).toBe(100);
  expect(getPriceSpy).toHaveResolved();
});

toHaveResolvedTimes

• Tür: (amount: number) => Awaitable<void>

Bu iddia, bir fonksiyonun belirli bir sayıda başarılı bir şekilde bir değeri çözdüğünü (yani, reddetmediğini) kontrol eder. expect'e bir casus fonksiyonu geçirilmesi gerekir.

Bu sadece çözülmüş promiseleri sayacaktır. Eğer fonksiyon bir promise döndürdüyse, ancak henüz çözülmediyse, sayılmaz.

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

test('casus fonksiyonu bir değeri iki kez çözdü', async () => {
  const sell = vi.fn((product: string) => Promise.resolve({ product }));

  await sell('apples');
  await sell('bananas');

  expect(sell).toHaveResolvedTimes(2);
});

toHaveResolvedWith

• Tür: (returnValue: any) => Awaitable<void>

Bu iddiayı, bir fonksiyonun belirli bir değeri en az bir kez başarılı bir şekilde çözdüğünü kontrol etmek için çağırabilirsiniz. expect'e bir casus fonksiyonu geçirilmesi gerekir.

Eğer fonksiyon bir promise döndürdüyse, ancak henüz çözülmediyse, bu başarısız olacaktır.

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

test('casus fonksiyonu bir ürünü çözdü', async () => {
  const sell = vi.fn((product: string) => Promise.resolve({ product }));

  await sell('apples');

  expect(sell).toHaveResolvedWith({ product: 'apples' });
});

toHaveLastResolvedWith

• Tür: (returnValue: any) => Awaitable<void>

Bu iddiayı, bir fonksiyonun son çağrıldığında belirli bir değeri başarılı bir şekilde çözdüğünü kontrol etmek için çağırabilirsiniz. expect'e bir casus fonksiyonu geçirilmesi gerekir.

Eğer fonksiyon bir promise döndürdüyse, ancak henüz çözülmediyse, bu başarısız olacaktır.

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

test('casus fonksiyonu son çağrıda muzları çözdü', async () => {
  const sell = vi.fn((product: string) => Promise.resolve({ product }));

  await sell('apples');
  await sell('bananas');

  expect(sell).toHaveLastResolvedWith({ product: 'bananas' });
});

toHaveNthResolvedWith

• Tür: (time: number, returnValue: any) => Awaitable<void>

Bu iddiayı, bir fonksiyonun belirli bir çağrıda belirli bir değeri başarılı bir şekilde çözdüğünü kontrol etmek için çağırabilirsiniz. expect'e bir casus fonksiyonu geçirilmesi gerekir.

Eğer fonksiyon bir promise döndürdüyse, ancak henüz çözülmediyse, bu başarısız olacaktır.

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

test('casus fonksiyonu ikinci çağrıda muzları döndürür', async () => {
  const sell = vi.fn((product: string) => Promise.resolve({ product }));

  await sell('apples');
  await sell('bananas');

  expect(sell).toHaveNthResolvedWith(2, { product: 'bananas' });
});

toSatisfy

• Tür: (predicate: (value: any) => boolean) => Awaitable<void>

Bu iddia, bir değerin belirli bir yüklemi karşılayıp karşılamadığını kontrol eder.

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

const isOdd = (value: number) => value % 2 !== 0;

describe('toSatisfy()', () => {
  it('1 ile geçer', () => {
    expect(1).toSatisfy(isOdd);
  });

  it('olumsuzlama ile geçer', () => {
    expect(2).not.toSatisfy(isOdd);
  });
});

resolves

• Tür: Promisify<Assertions>

resolves, eşzamansız kodu iddia ederken tekrarlayan kodları kaldırmak için tasarlanmıştır. Bekleyen promise'dan değeri çözmek ve değerini olağan iddialarla iddia etmek için kullanın. Eğer promise reddedilirse, iddia başarısız olur.

Aynı Assertions nesnesini döndürür, ancak tüm eşleştiriciler artık Promise döndürür, bu yüzden onu await etmeniz gerekir. chai iddialarıyla da çalışır.

Örneğin, bir API çağrısı yapan ve bazı verileri döndüren bir fonksiyonunuz varsa, dönüş değerini iddia etmek için bu kodu kullanabilirsiniz:

import { expect, test } from 'vitest';

async function buyApples() {
  return fetch('/buy/apples').then(r => r.json());
}

test('buyApples yeni stok kimliği döndürür', async () => {
  // toEqual şimdi bir promise döndürüyor, bu yüzden onu AWAIT etmeniz GEREKİYOR
  await expect(buyApples()).resolves.toEqual({ id: 1 }); // jest API
  await expect(buyApples()).resolves.to.equal({ id: 1 }); // chai API
});

WARNING

Eğer iddia beklenmezse, her zaman geçecek yanlış pozitif bir testle karşılaşırsınız. İddiaların gerçekten çağrıldığından emin olmak için expect.assertions(number) kullanabilirsiniz.

Vitest 3'ten beri, bir yöntem beklenmezse, Vitest testin sonunda bir uyarı gösterecektir. Vitest 4'te, iddia beklenmezse test "başarısız" olarak işaretlenecektir.

rejects

• Tür: Promisify<Assertions>

rejects, eşzamansız kodu iddia ederken tekrarlayan kodları kaldırmak için tasarlanmıştır. Promise'ın neden reddedildiğini çözmek ve değerini olağan iddialarla iddia etmek için kullanın. Eğer promise başarılı bir şekilde çözülürse, iddia başarısız olur.

Aynı Assertions nesnesini döndürür, ancak tüm eşleştiriciler artık Promise döndürür, bu yüzden onu await etmeniz gerekir. chai iddialarıyla da çalışır.

Örneğin, bir fonksiyonunuz varsa ve onu çağırdığınızda başarısız oluyorsa, nedeni iddia etmek için bu kodu kullanabilirsiniz:

import { expect, test } from 'vitest';

async function buyApples(id) {
  if (!id) {
    throw new Error('kimlik yok');
  }
}

test('buyApples kimlik sağlanmadığında hata fırlatır', async () => {
  // toThrow şimdi bir promise döndürüyor, bu yüzden onu AWAIT etmeniz GEREKİYOR
  await expect(buyApples()).rejects.toThrow('kimlik yok');
});

WARNING

Eğer iddia beklenmezse, her zaman geçecek yanlış pozitif bir testle karşılaşırsınız. İddiaların gerçekten çağrıldığından emin olmak için expect.assertions(number) kullanabilirsiniz.

Vitest 3'ten beri, bir yöntem beklenmezse, Vitest testin sonunda bir uyarı gösterecektir. Vitest 4'te, iddia beklenmezse test "başarısız" olarak işaretlenecektir.

expect.assertions

• Tür: (count: number) => void

Test geçtikten veya başarısız olduktan sonra, bir test sırasında belirli sayıda iddia çağrıldığını doğrulayın. Kullanışlı bir durum, eşzamansız bir kodun çağrılıp çağrılmadığını kontrol etmek olabilir.

Örneğin, eşzamansız olarak iki eşleştiriciyi çağıran bir fonksiyonumuz varsa, bunların gerçekten çağrıldığını iddia edebiliriz.

import { expect, test } from 'vitest';

async function doAsync(...cbs) {
  await Promise.all(cbs.map((cb, index) => cb({ index })));
}

test('tüm iddialar çağrıldı', async () => {
  expect.assertions(2);
  function callback1(data) {
    expect(data).toBeTruthy();
  }
  function callback2(data) {
    expect(data).toBeTruthy();
  }

  await doAsync(callback1, callback2);
});

WARNING

Eşzamansız eşzamanlı testlerle assertions kullanırken, doğru testin tespit edildiğinden emin olmak için yerel Test Bağlamı'ndan expect kullanılmalıdır.

expect.hasAssertions

• Tür: () => void

Test geçtikten veya başarısız olduktan sonra, test sırasında en az bir iddianın çağrıldığını doğrulayın. Kullanışlı bir durum, eşzamansız bir kodun çağrılıp çağrılmadığını kontrol etmek olabilir.

Örneğin, bir geri çağrıyı çağıran bir kodunuz varsa, geri çağrı içinde bir iddia yapabiliriz, ancak bir iddianın çağrılıp çağrılmadığını kontrol etmezsek test her zaman geçer.

import { expect, test } from 'vitest';
import { db } from './db.js';

const cbs = [];

function onSelect(cb) {
  cbs.push(cb);
}

// db'den seçim yaptıktan sonra tüm geri çağrıları çağırırız
function select(id) {
  return db.select({ id }).then(data => {
    return Promise.all(cbs.map(cb => cb(data)));
  });
}

test('geri çağrı çağrıldı', async () => {
  expect.hasAssertions();
  onSelect(data => {
    // seçimde çağrılmalı
    expect(data).toBeTruthy();
  });
  // beklenmezse, test başarısız olur
  // expect.hasAssertions() yoksa, test başarılı olur
  await select(3);
});

expect.unreachable

• Tür: (message?: string) => never

Bu yöntem, bir satıra asla ulaşılmaması gerektiğini iddia etmek için kullanılır.

Örneğin, build()'ın src klasörü olmayan dizinler aldığı için hata fırlattığını test etmek ve her hatayı ayrı ayrı ele almak istersek, bunu şöyle yapabiliriz:

import { expect, test } from 'vitest';

async function build(dir) {
  if (dir.includes('no-src')) {
    throw new Error(`${dir}/src does not exist`);
  }
}

const errorDirs = [
  'no-src-folder',
  // ...
];

test.each(errorDirs)('build "%s" ile başarısız oluyor', async dir => {
  try {
    await build(dir);
    expect.unreachable('Build geçmemeli');
  } catch (err: any) {
    expect(err).toBeInstanceOf(Error);
    expect(err.stack).toContain('build');

    switch (dir) {
      case 'no-src-folder':
        expect(err.message).toBe(`${dir}/src does not exist`);
        break;
      default:
        // tüm hata testlerini tüketmek için
        expect.unreachable('Tüm hata testleri ele alınmalıdır');
        break;
    }
  }
});

expect.anything

• Tür: () => any

Bu asimetrik eşleştirici, eşitlik kontrolüyle kullanıldığında her zaman true döndürür. Özelliğin var olduğundan emin olmak istiyorsanız kullanışlıdır.

import { expect, test } from 'vitest';

test('nesnenin "apples" anahtarı var', () => {
  expect({ apples: 22 }).toEqual({ apples: expect.anything() });
});

expect.any

• Tür: (constructor: unknown) => any

Bu asimetrik eşleştirici, bir eşitlik kontrolüyle kullanıldığında, yalnızca değer belirtilen bir yapıcı sınıfın bir örneği ise true döndürür. Her seferinde oluşturulan bir değeriniz varsa ve sadece doğru türde var olduğunu bilmek istiyorsanız kullanışlıdır.

import { expect, test } from 'vitest';
import { generateId } from './generators.js';

test('"id" bir sayı', () => {
  expect({ id: generateId() }).toEqual({ id: expect.any(Number) });
});

expect.closeTo

• Tür: (expected: any, precision?: number) => any

expect.closeTo, nesne özelliklerindeki veya dizi öğelerindeki kayan noktalı sayıları karşılaştırırken kullanışlıdır. Bir sayıyı karşılaştırmanız gerekiyorsa, bunun yerine .toBeCloseTo kullanın.

İsteğe bağlı precision argümanı, ondalık noktadan sonra kontrol edilecek basamak sayısını sınırlar. Varsayılan değer 2 için, test kriteri Math.abs(expected - received) < 0.005 (yani, 10 ** -2 / 2)'dir.

Örneğin, bu test 5 basamak hassasiyetle geçer:

test('nesne özelliklerindeki ondalık sayıyı karşılaştır', () => {
  expect({
    title: '0.1 + 0.2',
    sum: 0.1 + 0.2,
  }).toEqual({
    title: '0.1 + 0.2',
    sum: expect.closeTo(0.3, 5),
  });
});

expect.arrayContaining

• Tür: <T>(expected: T[]) => any

Bir eşitlik kontrolüyle kullanıldığında, bu asimetrik eşleştirici, değer bir dizi ise ve belirtilen öğeleri içeriyorsa true döndürür.

import { expect, test } from 'vitest';

test('sepet fuji içeriyor', () => {
  const basket = {
    varieties: ['Empire', 'Fuji', 'Gala'],
    count: 3,
  };
  expect(basket).toEqual({
    count: 3,
    varieties: expect.arrayContaining(['Fuji']),
  });
});

TIP

Beklenen değeri olumsuzlamak için bu eşleştiriciyle expect.not kullanabilirsiniz.

expect.objectContaining

• Tür: (expected: any) => any

Bir eşitlik kontrolüyle kullanıldığında, bu asimetrik eşleştirici, değer benzer bir şekle sahipse true döndürür.

import { expect, test } from 'vitest';

test('sepette empire elmalar var', () => {
  const basket = {
    varieties: [
      {
        name: 'Empire',
        count: 1,
      },
    ],
  };
  expect(basket).toEqual({
    varieties: [expect.objectContaining({ name: 'Empire' })],
  });
});

TIP

Beklenen değeri olumsuzlamak için bu eşleştiriciyle expect.not kullanabilirsiniz.

expect.stringContaining

• Tür: (expected: any) => any

Bir eşitlik kontrolüyle kullanıldığında, bu asimetrik eşleştirici, değer bir dize ise ve belirtilen bir alt dizeyi içeriyorsa true döndürür.

import { expect, test } from 'vitest';

test('çeşit adında "Emp" var', () => {
  const variety = {
    name: 'Empire',
    count: 1,
  };
  expect(variety).toEqual({
    name: expect.stringContaining('Emp'),
    count: 1,
  });
});

TIP

Beklenen değeri olumsuzlamak için bu eşleştiriciyle expect.not kullanabilirsiniz.

expect.stringMatching

• Tür: (expected: any) => any

Bir eşitlik kontrolüyle kullanıldığında, bu asimetrik eşleştirici, değer bir dize ise ve belirtilen bir alt dizeyi içeriyorsa veya dize bir düzenli ifadeyle eşleşiyorsa true döndürür.

import { expect, test } from 'vitest';

test('çeşit "re" ile bitiyor', () => {
  const variety = {
    name: 'Empire',
    count: 1,
  };
  expect(variety).toEqual({
    name: expect.stringMatching(/re$/),
    count: 1,
  });
});

TIP

Beklenen değeri olumsuzlamak için bu eşleştiriciyle expect.not kullanabilirsiniz.

expect.addSnapshotSerializer

• Tür: (plugin: PrettyFormatPlugin) => void

Bu yöntem, anlık görüntü oluşturulurken çağrılan özel serileştiriciler ekler. Bu gelişmiş bir özelliktir - daha fazla bilgi edinmek isterseniz, lütfen özel serileştiricilerle ilgili kılavuzu okuyabilirsiniz.

Özel serileştiriciler ekliyorsanız, bu yöntemi setupFiles içinde çağırmalısınız. Bu, her anlık görüntüyü etkileyecektir.

TIP

Daha önce Jest ile Vue CLI kullandıysanız, jest-serializer-vue kurmak isteyebilirsiniz. Aksi takdirde, anlık görüntüleriniz bir dizeye sarılır ve bu da " karakterinin kaçmasına yol açar.

expect.extend

• Tür: (matchers: MatchersObject) => void

Varsayılan eşleştiricileri kendi eşleştiricilerinizle genişletebilirsiniz. Bu fonksiyon, eşleştiriciler nesnesini özel eşleştiricilerle genişletmek amacıyla kullanılır.

Bu şekilde eşleştiricileri tanımladığınızda, expect.stringContaining gibi kullanılabilecek asimetrik eşleştiriciler de oluşturursunuz.

import { expect, test } from 'vitest';

test('özel eşleştiriciler', () => {
  expect.extend({
    toBeFoo: (received, expected) => {
      if (received !== 'foo') {
        return {
          message: () => `beklenen ${received} foo olmalıydı`,
          pass: false,
        };
      }
    },
  });

  expect('foo').toBeFoo();
  expect({ foo: 'foo' }).toEqual({ foo: expect.toBeFoo() });
});

TIP

Eşleştiricilerinizin her testte görünmesini istiyorsanız, bu yöntemi setupFiles içinde çağırmanız gerekir.

Bu fonksiyon Jest'in expect.extend ile uyumludur, bu nedenle özel eşleştiriciler oluşturmak için onu kullanan herhangi bir kütüphane Vitest ile çalışacaktır.

TypeScript kullanıyorsanız, Vitest 0.31.0'dan beri varsayılan Assertion arayüzünü ortam bildirim dosyasında (örneğin: vitest.d.ts) aşağıdaki kodla genişletebilirsiniz:

interface CustomMatchers<R = unknown> {
  toBeFoo: () => R;
}

declare module 'vitest' {
  interface Assertion<T = any> extends CustomMatchers<T> {}
  interface AsymmetricMatchersContaining extends CustomMatchers {}
}

WARNING

Ortam bildirim dosyasını tsconfig.json dosyanıza eklemeyi unutmayın.

TIP

Daha fazla bilgi edinmek isterseniz, eşleştiricileri genişletme kılavuzuna göz atın.

expect.addEqualityTesters

• Tür: (tester: Array<Tester>) => void

Bu yöntemi, eşleştiriciler tarafından iki nesnenin eşit olup olmadığını test etmek için kullanılan özel test edicileri tanımlamak için kullanabilirsiniz. Jest'in expect.addEqualityTesters ile uyumludur.

import { expect, test } from 'vitest';

class AnagramComparator {
  public word: string;

  constructor(word: string) {
    this.word = word;
  }

  equals(other: AnagramComparator): boolean {
    const cleanStr1 = this.word.replace(/ /g, '').toLowerCase();
    const cleanStr2 = other.word.replace(/ /g, '').toLowerCase();

    const sortedStr1 = cleanStr1.split('').sort().join('');
    const sortedStr2 = cleanStr2.split('').sort().join('');

    return sortedStr1 === sortedStr2;
  }
}

function isAnagramComparator(a: unknown): a is AnagramComparator {
  return a instanceof AnagramComparator;
}

function areAnagramsEqual(a: unknown, b: unknown): boolean | undefined {
  const isAAnagramComparator = isAnagramComparator(a);
  const isBAnagramComparator = isAnagramComparator(b);

  if (isAAnagramComparator && isBAnagramComparator) {
    return a.equals(b);
  } else if (isAAnagramComparator === isBAnagramComparator) {
    return undefined;
  } else {
    return false;
  }
}

expect.addEqualityTesters([areAnagramsEqual]);

test('özel eşitlik test cihazı', () => {
  expect(new AnagramComparator('listen')).toEqual(
    new AnagramComparator('silent')
  );
});