expect

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

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

expect (beklenti), doğrulama (assertion) oluşturmak için kullanılır. Bu bağlamda assertions, bir ifadeyi test etmek için çağrılabilen fonksiyonlardır. Vitest, varsayılan olarak chai doğrulamalarını ve ayrıca chai üzerine inşa edilmiş Jest uyumlu doğrulamaları destekler.

Örneğin, aşağıdaki kod bir input değerinin 2'ye eşit olduğunu doğrular. Eşit değilse, doğrulama 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

Teknik olarak bu örnek test fonksiyonunu kullanmaz, bu nedenle konsolda Vitest çıktısı yerine Node.js hatası görürsünüz. test hakkında daha fazla bilgi edinmek için lütfen Test API Referansı'nı okuyun.

Ek olarak, expect statik olarak kullanılarak, aşağıda açıklanan karşılaştırıcı (matcher) fonksiyonlara ve diğer özelliklere erişilebilir.

WARNING

expect, ifadede bir tür hatası yoksa, türleri test etmede etkili değildir. Vitest'i tür denetleyicisi olarak kullanmak istiyorsanız, expectTypeOf veya assertType kullanın.

soft

• Tip: ExpectStatic & (actual: any) => Assertions

expect.soft, expect'e benzer şekilde çalışır. Ancak, başarısız bir doğrulama durumunda test yürütmesini durdurmak 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ülenir.

import { expect, test } from 'vitest';

test('expect.soft testi', () => {
  expect.soft(1 + 1).toBe(3); // Testi başarısız olarak işaretle ve devam et
  expect.soft(1 + 2).toBe(4); // Testi başarısız olarak işaretle ve devam et
});
// Testin sonunda, yukarıdaki hatalar çıktılanacaktır.

Aynı zamanda expect ile birlikte de kullanılabilir. expect doğrulaması başarısız olursa, test sonlandırılır ve tüm hatalar görüntülenir.

import { expect, test } from 'vitest';

test('expect.soft testi', () => {
  expect.soft(1 + 1).toBe(3); // Testi başarısız olarak işaretle ve devam et
  expect(1 + 2).toBe(4); // Başarısız oldu ve testi sonlandırdı, önceki tüm hatalar çıktılanacak
  expect.soft(1 + 3).toBe(5); // Çalıştırılmayacak
});

WARNING

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

not

not kullanmak, doğrulamayı olumsuzlar. Örneğin, aşağıdaki kod bir input değerinin 2'ye eşit olmadığını doğrular. Eşitse, doğrulama 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

• Tip: (value: any) => Awaitable<void>

toBe, temel veri türlerinin eşit olup olmadığını veya nesnelerin aynı referansı paylaşıp paylaşmadığını doğrulamak için kullanılabilir. expect(Object.is(3, 3)).toBe(true) çağırmakla eşdeğerdir. Nesneler aynı değilse, ancak yapılarının aynı olup olmadığını kontrol etmek istiyorsanız, toEqual kullanabilirsiniz.

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

import { expect, test } from 'vitest';

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

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

test('stocks are the same', () => {
  const refStock = stock; // Aynı referans

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

toBe'yi ondalıklı sayılarla kullanmamaya çalışın. JavaScript'te kayan noktalı sayılar yuvarlandığı için 0.1 + 0.2 sonucu tam olarak 0.3'e eşit olmayabilir. Ondalıklı sayıları güvenilir bir şekilde doğrulamak için toBeCloseTo doğrulamasını kullanın.

toBeCloseTo

• Tip: (value: number, numDigits?: number) => Awaitable<void>

Ondalıklı 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('decimals are not equal in javascript', () => {
  expect(0.2 + 0.1).toBe(0.3); // 0.2 + 0.1, 0.30000000000000004'tür
});

test('decimals are rounded to 5 after the point', () => {
  // 0.2 + 0.1 is 0.30000 | "000000000004" removed
  expect(0.2 + 0.1).toBeCloseTo(0.3, 5);
  // nothing from 0.30000000000000004 is removed
  expect(0.2 + 0.1).not.toBeCloseTo(0.3, 50);
});

toBeDefined

• Tip: () => Awaitable<void>

toBeDefined, değerin undefined'a eşit olmadığını doğrular. Bir fonksiyonun değer 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('function returned something', () => {
  expect(getApples()).toBeDefined();
});

toBeUndefined

• Tip: () => Awaitable<void>

toBeDefined'ın zıttı olan toBeUndefined, değerin undefined'a eşit olduğunu doğrular. Bir fonksiyonun değer 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 doesn't have a stock", () => {
  expect(getApplesFromStock('Mary')).toBeUndefined();
});

toBeTruthy

• Tip: () => Awaitable<void>

toBeTruthy, boolean'a dönüştürüldüğünde değerin doğru (true) olduğunu doğrular. Değerin kendisiyle ilgilenmek yerine, true değerine dönüştürülebilir olup olmadığını kontrol etmek için kullanışlıdır.

Örneğin, bu koda sahipseniz 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 nedenle, stocks.getInfo'nun doğru (truthy) olacağını test etmek istiyorsanız, şunu yazabilirsiniz:

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

const stocks = new Stocks();

test('if we know Bill stock, sell apples to him', () => {
  stocks.sync('Bill');
  expect(stocks.getInfo('Bill')).toBeTruthy();
});

JavaScript'teki her şey false, null, undefined, NaN, 0, -0, 0n, "" ve document.all dışında true değer döndürür.

toBeFalsy

• Tip: () => Awaitable<void>

toBeFalsy, boolean'a dönüştürüldüğünde değerin yanlış (false) olduğunu doğrular. Değerin kendisiyle ilgilenmek yerine, false değerine dönüştürülebilir olup olmadığını kontrol etmek için kullanışlıdır.

Örneğin, bu koda sahipseniz 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 nedenle, stocks.stockFailed'ın yanlış (falsy) olacağını test etmek istiyorsanız, şunu yazabilirsiniz:

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

const stocks = new Stocks();

test("if Bill stock hasn't failed, sell apples to him", () => {
  stocks.syncStocks('Bill');
  expect(stocks.stockFailed('Bill')).toBeFalsy();
});

JavaScript'teki her şey false, null, undefined, NaN, 0, -0, 0n, "" ve document.all dışında true değer döndürür.

toBeNull

• Tip: () => Awaitable<void>

toBeNull, basitçe bir şeyin null olup olmadığını doğrular. .toBe(null) için takma ad.

import { expect, test } from 'vitest';

function apples() {
  return null;
}

test("we don't have apples", () => {
  expect(apples()).toBeNull();
});

toBeNaN

• Tip: () => Awaitable<void>

toBeNaN, basitçe bir şeyin NaN olup olmadığını doğrular. .toBe(NaN) için takma ad.

import { expect, test } from 'vitest';

let i = 0;

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

test('getApplesCount has some unusual side effects...', () => {
  expect(getApplesCount()).not.toBeNaN();
  expect(getApplesCount()).toBeNaN();
});

toBeTypeOf

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

toBeTypeOf, değerin, belirtilen türde olup olmadığını kontrol eder.

import { expect, test } from 'vitest';

const actual = 'stock';

test('stock is type of string', () => {
  expect(actual).toBeTypeOf('string');
});

toBeInstanceOf

• Tip: (c: any) => Awaitable<void>

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

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

const stocks = new Stocks();

test('stocks are instance of Stocks', () => {
  expect(stocks).toBeInstanceOf(Stocks);
});

toBeGreaterThan

• Tip: (n: number | bigint) => Awaitable<void>

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

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

test('have more then 10 apples', () => {
  expect(getApples()).toBeGreaterThan(10);
});

toBeGreaterThanOrEqual

• Tip: (n: number | bigint) => Awaitable<void>

toBeGreaterThanOrEqual, gerçek değerin alınandan büyük veya ona eşit olup olmadığını doğrular.

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

test('have 11 apples or more', () => {
  expect(getApples()).toBeGreaterThanOrEqual(11);
});

toBeLessThan

• Type: (n: number | bigint) => Awaitable<void>

toBeLessThan, gerçek değerin alınandan küçük olup olmadığını doğrular. Eşit değerler testi başarısız kılar.

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

test('have less then 20 apples', () => {
  expect(getApples()).toBeLessThan(20);
});

toBeLessThanOrEqual

• Type: (n: number | bigint) => Awaitable<void>

toBeLessThanOrEqual, gerçek değerin alınandan küçük veya ona eşit olup olmadığını doğrular.

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

test('have 11 apples or less', () => {
  expect(getApples()).toBeLessThanOrEqual(11);
});

toEqual

• Type: (received: any) => Awaitable<void>

toEqual, değerin, beklenen değerle aynı olup olmadığını veya bir nesne ise aynı yapıya sahip olup olmadığını (özyinelemeli olarak karşılaştırarak) kontrol 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('stocks have the same properties', () => {
  expect(stockBill).toEqual(stockMary);
});

test('stocks are not the same', () => {
  expect(stockBill).not.toBe(stockMary);
});

WARNING

Error nesneleri için derinlemesine eşitlik kontrolü yapılmayacaktır. Sadece bir Error'ın message özelliği eşitlik için dikkate alınır. message dışındaki özellikleri kontrol etmek için eşitliği özelleştirmek isterseniz expect.addEqualityTesters kullanın. Bir şeyin fırlatılıp fırlatılmadığını test etmek için toThrowError assertion'ını kullanın.

toStrictEqual

• Type: (received: any) => Awaitable<void>

toStrictEqual, değerin, beklenen değerle aynı olup olmadığını veya bir nesne ise aynı yapıya ve türe sahip olup olmadığını (özyinelemeli olarak karşılaştırarak) kontrol eder.

.toEqual farklılıkları:

• undefined özelliklere sahip anahtarlar kontrol edilir. Örneğin, .toStrictEqual kullanılırken {a: undefined, b: 2}, {b: 2} ile eşleşmez.
• Seyrek diziler kontrol edilir. Örneğin, .toStrictEqual kullanılırken [, 1], [undefined, 1] ile eşleşmez.
• Nesne türlerinin eşit olup olmadığı kontrol edilir. Örneğin, a ve b özelliklerine sahip bir sınıf örneği, aynı a ve b özelliklerine sahip bir nesne literal'ine eşit olmayacaktır.

import { expect, test } from 'vitest';

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

test('structurally the same, but semantically different', () => {
  expect(new Stock('apples')).toEqual({ type: 'apples' });
  expect(new Stock('apples')).not.toStrictEqual({ type: 'apples' });
});

toContain

• Tipi: (received: string) => Awaitable<void>

toContain, gerçek değerin bir dizide olup olmadığını doğrular. toContain ayrıca bir dizenin başka bir dizenin alt dizesi olup olmadığını da kontrol edebilir. Vitest 1.0'dan beri, testleri tarayıcı benzeri bir ortamda çalıştırıyorsanız, bu assertion bir sınıfın classList içinde 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 orange içeriyor', () => {
  expect(getAllFruits()).toContain('orange');

  const element = document.querySelector('#el');
  // element bir sınıfa sahip
  expect(element.classList).toContain('flex');
  // element başka bir öğenin içinde
  expect(document.querySelector('#wrapper')).toContain(element);
});

toContainEqual

• Type: (received: any) => Awaitable<void>

toContainEqual, belirli bir yapıya ve değerlere sahip bir öğenin bir dizide olup olmadığını doğrular. Dizideki her bir eleman için toEqual metodu uygulanmış gibi çalışır.

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

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

toHaveLength

• Type: (received: number) => Awaitable<void>

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

import { expect, test } from 'vitest';

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

  expect('').not.toHaveLength(3);
  expect({ length: 3 }).toHaveLength(3);
});

toHaveProperty

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

toHaveProperty, belirtilen key değerine sahip bir özelliğin bir nesnede bulunup bulunmadığını kontrol eder.

Alınan özellik değerini karşılaştırmak için, isteğe bağlı bir değer argümanı sağlayarak toEqual eşleştiricisindeki gibi derinlemesine bir karşılaştırma yapabilirsiniz.

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 varlığını doğrula
  expect(invoice).toHaveProperty('total_amount', 5000); // anahtarın varlığını ve değerin eşit olduğunu doğrula

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

  // Nokta gösterimi kullanarak derinlemesine 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 derinlemesine referanslama
  expect(invoice).toHaveProperty('items[0].type', 'apples');
  expect(invoice).toHaveProperty('items.0.type', 'apples'); // nokta gösterimi de çalışır

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

  // Anahtarınızın derin bir 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 normal ifadeyle veya başka bir dizeyle eşleşip eşleşmediğini kontrol eder.

import { expect, test } from 'vitest';

test('en popüler meyveler', () => {
  expect('en iyi meyveler elma, portakal ve üzümü içerir').toMatch(/apple/);
  expect('elma meyveleri').toMatch('meyve'); // toMatch bir dizeyi de kabul eder
});

toMatchObject

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

toMatchObject, bir nesnenin belirtilen özelliklere sahip olup olmadığını doğrular. Başka bir deyişle, beklenen nesnenin tüm özelliklerinin, test edilen nesnede aynı değerlerle bulunup bulunmadığını kontrol eder.

Ayrıca bir nesne dizisi de gönderebilirsiniz. Bu, arrayContaining'in aksine (ki bu alınan dizide fazladan öğelere izin verir), iki dizinin eleman sayısının tam olarak eşleştiğini kontrol etmek istediğinizde kullanışlıdır.

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 kişisel bilgileri var', () => {
  expect(johnInvoice).toMatchObject(johnDetails);
});

test('öğe sayısı tam olarak eşleşmeli', () => {
  // Bir nesne dizisinin eşleştiğini doğrulayın
  expect([{ foo: 'bar' }, { baz: 1 }]).toMatchObject([
    { foo: 'bar' },
    { baz: 1 },
  ]);
});

toThrowError

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

• Diğer Adı: toThrow

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

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

• normal ifade: hata mesajı bu kalıpla eşleşir
• dize: hata mesajı bu alt dizeyi içerir

TIP

Kodu bir fonksiyon içine almalısınız, aksi takdirde hata yakalanamaz ve test başarısız olur.

Örneğin, getFruitStock('ananas') fonksiyonunun bir hata fırlattığını test etmek istersek, aşağıdaki gibi bir kod 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 edin: bunlar eşdeğerdir
  expect(() => getFruitStock('pineapples')).toThrowError(/stock/);
  expect(() => getFruitStock('pineapples')).toThrowError('stock');

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

TIP

Asenkron fonksiyonları test etmek için rejects ile birlikte kullanın.

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

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

toMatchSnapshot

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

Bu, bir değerin en son anlık görüntüyle eşleşmesini sağlar.

Test adına eklenecek isteğe bağlı bir hint (ipucu) dize argümanı belirtebilirsiniz. Vitest her zaman bir anlık görüntü adının sonuna bir sayı eklese bile, kısa ve açıklayıcı ipuçları, tek bir test bloğundaki birden fazla anlık görüntüyü ayırt etmek için sayılardan daha kullanışlı olabilir.

TIP

Anlık görüntüde bir uyuşmazlık varsa ve bu testin başarısız olmasına neden oluyorsa ve bu uyuşmazlık bekleniyorsa, anlık görüntüyü tek seferlik 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şir', () => {
  const data = { foo: new Set(['bar', 'anlık görüntü']) };
  expect(data).toMatchSnapshot();
});

Sadece bir nesnenin ş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şir', () => {
  const data = { foo: new Set(['bar', 'anlık görüntü']) };
  expect(data).toMatchSnapshot({ foo: expect.any(Set) });
});

toMatchInlineSnapshot

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

Bu, bir değerin en son anlık görüntüyle eşleşmesini sağlar.

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

import { expect, test } from 'vitest';

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

Sadece bir nesnenin ş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şir', () => {
  const data = { foo: new Set(['bar', 'anlık görüntü']) };
  expect(data).toMatchInlineSnapshot(
    { foo: expect.any(Set) },
    `
    {
      "foo": Any<Set>,
    }
  `
  );
});

toMatchFileSnapshot 0.30.0+

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

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

import { expect, it } from 'vitest';

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

Dosya sistemi işlemi asenkron olduğundan, toMatchFileSnapshot() ile await kullanmanız gerektiğini unutmayın.

toThrowErrorMatchingSnapshot

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

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

toThrowErrorMatchingInlineSnapshot

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

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

toHaveBeenCalled

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

Bu assertion, bir fonksiyonun çağrılıp çağrılmadığını test etmek için kullanışlıdır. expect'e bir izleme (spy) fonksiyonunun geçirilmesini gerektirir.

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

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

test('izleme 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 assertion, bir fonksiyonun belirli sayıda çağrılıp çağrılmadığını kontrol eder. expect'e bir izleme (spy) fonksiyonunun geçirilmesini gerektirir.

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

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

test('izleme 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 assertion, bir fonksiyonun belirli parametrelerle en az bir kez çağrılıp çağrılmadığını kontrol eder. expect'e bir izleme (spy) fonksiyonunun geçirilmesini gerektirir.

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

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

test('izleme 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);
});

toHaveBeenLastCalledWith

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

Bu assertion, bir fonksiyonun son çağrısında belirli parametrelerle çağrılıp çağrılmadığını kontrol eder. expect'e bir izleme (spy) fonksiyonunun geçirilmesini gerektirir.

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

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

test('izleme 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 assertion, bir fonksiyonun belirli bir sırada belirli parametrelerle çağrılıp çağrılmadığını kontrol eder. Sayım 1'den başlar. Yani, ikinci girişi kontrol etmek için .toHaveBeenNthCalledWith(2, ...) yazarsınız.

expect'e bir izleme (spy) fonksiyonunun geçirilmesini gerektirir.

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

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

test('izleme 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 assertion, bir fonksiyonun en az bir kez başarıyla bir değer döndürüp döndürmediğini kontrol eder (yani, bir hata fırlatmadı). expect'e bir izleme (spy) fonksiyonunun geçirilmesini gerektirir.

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

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

test('izleme 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 assertion, bir fonksiyonun tam olarak belirli sayıda başarıyla bir değer döndürüp döndürmediğini kontrol eder (yani, bir hata fırlatmadı). expect'e bir izleme (spy) fonksiyonunun geçirilmesini gerektirir.

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

test('izleme fonksiyonu iki kez bir 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 doğrulama, bir fonksiyonun belirli parametrelerle en az bir kez başarıyla bir değer döndürüp döndürmediğini kontrol etmek için kullanılır. expect'e bir izleme fonksiyonu geçirilmesini gerektirir.

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

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

  sell('apples');

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

toHaveLastReturnedWith

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

Bu doğrulama, bir fonksiyonun son çağrısında belirli parametrelerle başarıyla bir değer döndürüp döndürmediğini kontrol etmek için kullanılır. expect'e bir izleme fonksiyonu geçirilmesini gerektirir.

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

test('izleme fonksiyonu son çağrıda muz döndürüyor', () => {
  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 doğrulama, bir fonksiyonun belirli bir çağrısında belirli parametrelerle başarıyla bir değer döndürüp döndürmediğini kontrol etmek için kullanılır. expect'e bir izleme fonksiyonu geçirilmesini gerektirir.

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

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

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

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

toSatisfy

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

Bu doğrulama, bir değerin belirli bir koşulu (predicate) karşılayıp karşılamadığını kontrol eder.

import { describe, expect, it } from 'vitest';
describe('toSatisfy()', () => {
  const isOdd = (value: number) => value % 2 !== 0;

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

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

resolves

• Tür: Promisify<Assertions>

resolves, asenkron kod doğrulanırken gereksiz kod tekrarını önlemek için tasarlanmıştır. Bekleyen promise'in değerini almak ve bu değeri normal iddialarla kontrol etmek için kullanın. Promise reddedilirse, doğrulama 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 nedenle await etmeniz gerekir. chai iddialarıyla da çalışır.

Örneğin, bir API çağrısı yapan ve bazı veriler döndüren bir fonksiyonunuz varsa, dönüş değerini kontrol etmek için şu 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üyor', async () => {
  // toEqual artık bir promise döndürdüğü için await etmeniz gerekir
  await expect(buyApples()).resolves.toEqual({ id: 1 }); // jest API
  await expect(buyApples()).resolves.to.equal({ id: 1 }); // chai API
});

WARNING

İddia await edilmezse, her zaman başarılı olacak hatalı bir testiniz olur. İddiaların gerçekten çağrıldığından emin olmak için expect.assertions(number) kullanabilirsiniz.

rejects

• Tür: Promisify<Assertions>

rejects, asenkron kod doğrulanırken gereksiz kod tekrarını önlemek için tasarlanmıştır. Promise'in neden reddedildiğini almak ve bu değeri normal iddialarla kontrol etmek için kullanın. Promise başarıyla çözülürse, doğrulama 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 nedenle await etmeniz gerekir. chai iddialarıyla da çalışır.

Örneğin, çağırdığınızda başarısız olan bir fonksiyonunuz varsa, nedeni kontrol etmek için şu kodu kullanabilirsiniz:

import { expect, test } from 'vitest';

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

test('buyApples, kimlik sağlanmadığında bir hata fırlatıyor', async () => {
  // toThrow artık bir promise döndürdüğü için await etmeniz gerekir
  await expect(buyApples()).rejects.toThrow('no id');
});

WARNING

İddia await edilmezse, her zaman başarılı olacak hatalı bir testiniz olur. İddiaların gerçekten çağrıldığından emin olmak için expect.assertions(number) kullanabilirsiniz.

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 iddianın çağrılıp çağrılmadığını doğrular. Bu, özellikle asenkron kodun çağrılıp çağrılmadığını kontrol etmek için kullanışlıdır.

Örneğin, asenkron 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ılıyor', async () => {
  expect.assertions(2);
  function callback1(data) {
    expect(data).toBeTruthy();
  }
  function callback2(data) {
    expect(data).toBeTruthy();
  }

  await doAsync(callback1, callback2);
});

WARNING

Eş zamanlı asenkron testlerde assertions kullanırken, doğru testin algılandığından 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, bir test sırasında en az bir iddianın çağrılıp çağrılmadığını doğrular. Bu, özellikle asenkron kodun çağrılıp çağrılmadığını kontrol etmek için kullanışlıdır.

Örneğin, bir callback çağıran bir kodunuz varsa, bir callback içinde bir iddia yapabiliriz, ancak iddianın çağrılıp çağrılmadığını kontrol etmezsek test her zaman başarılı olur.

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 callback'leri çağırıyoruz
function select(id) {
  return db.select({ id }).then(data => {
    return Promise.all(cbs.map(cb => cb(data)));
  });
}

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

expect.unreachable

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

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

Örneğin, build() fonksiyonunun src klasörü olmayan dizinleri alması nedeniyle hata fırlattığını test etmek ve ayrıca her hatayı ayrı ayrı ele almak istiyorsak, şunu 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 olur', async dir => {
  try {
    await build(dir);
    expect.unreachable('Build başarılı olmamalı');
  } 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 senaryolarını kapsamak için
        expect.unreachable('Tüm hata senaryoları ele alınmalıdır');
        break;
    }
  }
});

expect.anything

• Tür: () => any

Bu asimetrik eşleştirici, eşitlik kontrolü ile kullanıldığında her zaman true döndürür. Sadece özelliğin var olup olmadığını kontrol etmek istediğinizde 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, eşitlik kontrolü ile kullanıldığında, yalnızca değer belirtilen bir yapıcının örneği ise true döndürür. Eğer her seferinde yeni bir değer oluşturuluyorsa ve sadece doğru türde olduğundan emin olmak istiyorsanız kullanışlıdır.

expect.closeTo 1.0.0+

• Tipi: (expected: any, precision?: number) => any

expect.closeTo, kayan noktalı sayıları nesne özelliklerinde veya dizi öğelerinde 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ı numDigits argümanı, ondalık noktadan sonraki kontrol edilecek basamak sayısını sınırlar. Varsayılan değer olan 2 için, test kriteri Math.abs(expected - received) < 0.005 (yani, 10 ** -2 / 2).

Örneğin, bu test 5 basamaklık bir hassasiyetle geçer:

test('nesne özelliklerinde kayan 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),
  });
});

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

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

expect.arrayContaining

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

Eşitlik kontrolü ile 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

Eşitlik kontrolü ile kullanıldığında, bu asimetrik eşleştirici, değer benzer bir yapıya 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

Eşitlik kontrolü ile 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şidin 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

Eşitlik kontrolü ile kullanıldığında, bu asimetrik eşleştirici, değer bir dize ise ve belirtilen bir alt dizeyi içeriyorsa veya dize normal 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üler oluşturulurken kullanılan özel serileştiriciler ekler. Bu gelişmiş bir özelliktir - daha fazla bilgi edinmek istiyorsanız, lütfen özel serileştiriciler kılavuzunu okuyun.

Ö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 yüklemek isteyebilirsiniz. Aksi takdirde, anlık görüntüleriniz bir dize içine alınır ve bu da " karakterinin kaçış karakteriyle belirtilmesine neden olur.

expect.extend

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

Varsayılan eşleştiricileri kendinizinkilerle genişletebilirsiniz. Bu fonksiyon, eşleştiriciler nesnesini özel eşleştiricilerle genişletmek için kullanılır.

Eşleştiricileri bu şekilde tanımladığınızda, expect.stringContaining gibi kullanılabilen asimetrik eşleştiriciler de oluşturabilirsiniz.

import { expect, test } from 'vitest';

test('özel eşleştiriciler', () => {
  expect.extend({
    toBeFoo: (received, expected) => {
      if (received !== 'foo') {
        return {
          message: () => `${received}'in foo olması bekleniyordu`,
          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ğırmalısınız.

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

TypeScript kullanıyorsanız, Vitest 0.31.0'dan beri, aşağıdaki kodla varsayılan Assertion arayüzünü bir ortam bildirim dosyasında (örneğin: vitest.d.ts) 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 istiyorsanız, eşleştiricileri genişletme kılavuzuna göz atın.

expect.addEqualityTesters 1.2.0+

• Tipi: (tester: Array<Tester>) => void

İki nesnenin eşit olup olmadığını test etmek için eşleşmeler tarafından kullanılan yöntemler olan özel test araçları tanımlamak için bu yöntemi 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 = isBAnagramComparator(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 aracı', () => {
  expect(new AnagramComparator('listen')).toEqual(
    new AnagramComparator('silent')
  );
});