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(3); // Başarısız oldu ve testi sonlandırdı, önceki tüm hatalar çıktılanacak
  expect.soft(1 + 2).toBe(4); // Ç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) {
  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, 0, '', null, undefined ve NaN 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, 0, '', null, undefined ve NaN 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 tam karşılaştırma yapılmayacaktır. Bir şeyin fırlatılıp fırlatılmadığını test etmek için toThrowError doğrulaması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

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

toContain, gerçek değerin bir dizide olup olmadığını doğrular. toContain metodu, bir dizenin başka bir dizenin içinde yer alıp almadığını da kontrol edebilir.

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

test('the fruit list contains orange', () => {
  expect(getAllFruits()).toContain('orange');
});

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

TIP

Hata mesajındaki değer çok kısaltılmışsa, yapılandırma dosyanızdaki chaiConfig.truncateThreshold değerini artırabilirsiniz.

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) {
    if (type === 'pineapples')
      throw new DiabetesError('Ananaslar diyabet hastaları için iyi değildir');
  
    // Başka şeyler yap
  }
  
  test('ananaslarda hata fırlatır', () => {
    // Hata mesajının bir yerinde "diyabet" yazdığını test edin: bunlar eşdeğerdir
    expect(() => getFruitStock('pineapples')).toThrowError(/diabetes/);
    expect(() => getFruitStock('pineapples')).toThrowError('diabetes');
  
    // Tam hata mesajını test edin
    expect(() => getFruitStock('pineapples')).toThrowError(
      /^Ananaslar diyabet hastaları için iyi değildir$/
    );
  });

  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

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

• Sürüm: Vitest 0.30.0'dan beri

  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.

  Eğer fonksiyon bir Error fırlatırsa, anlık görüntü hata mesajının içeriği olacaktır. Aksi takdirde, anlık görüntü fonksiyon tarafından fırlatılan değer olacaktır.

toThrowErrorMatchingInlineSnapshot

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

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

  Eğer fonksiyon bir Error fırlatırsa, anlık görüntü hata mesajının içeriği olacaktır. Aksi takdirde, anlık görüntü fonksiyon tarafından fırlatılan değer olacaktır.

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.

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.

  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.