expect

Az alábbi típusok a lentebb található típusjelölésekben szerepelnek.

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

Az expect függvény állítások (assertions) létrehozására szolgál. Ebben a kontextusban az állítások olyan függvények, amelyek meghívhatók egy feltétel megerősítésére. A Vitest alapértelmezetten chai állításokat biztosít, valamint a chai tetejére épített Jest kompatibilis állításokat. A Jest-tel ellentétben a Vitest támogatja az üzenetet második argumentumként – ha az állítás sikertelen, a hibaüzenet megegyezik ezzel az üzenettel.

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

Például ez a kód azt állítja, hogy egy input érték egyenlő 2-vel. Ha nem, az állítás hibát dob, és a teszt sikertelen lesz.

import { expect } from 'vitest';

const input = Math.sqrt(4);

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

Technikailag ez a példa nem használja a test függvényt, így a konzolon Node.js hibát fog látni a Vitest kimenete helyett. A test-ről további információkért olvassa el a Test API Reference részt.

Az expect statikusan is használható a matcher függvények eléréséhez, amelyeket később ismertetünk, és még sok máshoz.

WARNING

Az expect nem befolyásolja a típusok tesztelését, ha a kifejezésnek nincs típushibája. Ha a Vitestet típusellenőrzőként szeretné használni, használja az expectTypeOf vagy az assertType függvényt.

soft

• Típus: ExpectStatic & (actual: any) => Assertions

Az expect.soft hasonlóan működik, mint az expect, de ahelyett, hogy egy sikertelen állítás esetén megszakítaná a teszt végrehajtását, tovább fut, és a hibát teszthibaként jelöli meg. A teszt során felmerült összes hiba megjelenik, amíg a teszt be nem fejeződik.

import { expect, test } from 'vitest';

test('expect.soft test', () => {
  expect.soft(1 + 1).toBe(3); // a tesztet sikertelennek jelöli és folytatja
  expect.soft(1 + 2).toBe(4); // a tesztet sikertelennek jelöli és folytatja
});
// a riporter mindkét hibát jelenti a futás végén

Az expect-kel is használható. Ha az expect állítás sikertelen, a teszt leáll, és az összes korábbi hiba kiíródik.

import { expect, test } from 'vitest';

test('expect.soft test', () => {
  expect.soft(1 + 1).toBe(3); // a tesztet sikertelennek jelöli és folytatja
  expect(1 + 2).toBe(4); // sikertelen és leállítja a tesztet, az összes korábbi hiba kiíródik
  expect.soft(1 + 3).toBe(5); // nem fut le
});

WARNING

Az expect.soft csak a test függvényen belül használható.

poll

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

Az expect.poll addig futtatja újra az állításokat, amíg azok sikeresek nem lesznek. Konfigurálhatja, hogy a Vitest hányszor futtassa újra az expect.poll visszahívást az interval és timeout opciók beállításával.

Ha hiba történik az expect.poll visszahíváson belül, a Vitest újrapróbálkozik, amíg az időtúllépés le nem jár.

import { expect, test } from 'vitest';

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

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

WARNING

Az expect.poll minden állítást aszinkronná tesz, ezért meg kell várnia. A Vitest 3 óta, ha elfelejti megvárni, a teszt figyelmeztetéssel sikertelen lesz.

Az expect.poll nem működik több matcherrel:

• A snapshot matcherek nem támogatottak, mert mindig sikeresek lesznek. Ha a feltétele bizonytalan, fontolja meg a vi.waitFor használatát a probléma első megoldásához:

import { expect, vi } from 'vitest';

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

• A .resolves és .rejects nem támogatottak. Az expect.poll már megvárja a feltételt, ha az aszinkron.
• A toThrow és aliasai nem támogatottak, mert az expect.poll feltétel mindig feloldódik, mielőtt a matcher megkapja az értéket.

not

A not használata negálja az állítást. Például ez a kód azt állítja, hogy egy input érték nem egyenlő 2-vel. Ha egyenlő, az állítás hibát dob, és a teszt sikertelen lesz.

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ípus: (value: any) => Awaitable<void>

A toBe használható primitívek egyenlőségének vagy objektumok azonos referenciájának ellenőrzésére. Ez egyenértékű az expect(Object.is(3, 3)).toBe(true) hívásával. Ha az objektumok nem azonosak, de ellenőrizni szeretné, hogy a struktúrájuk azonos-e, használhatja a toEqual függvényt.

Például az alábbi kód ellenőrzi, hogy a kereskedőnek van-e 13 almája.

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; // azonos referencia

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

Kerülje a toBe használatát lebegőpontos számokkal. Mivel a JavaScript kerekíti őket, a 0.1 + 0.2 nem szigorúan 0.3. A lebegőpontos számok megbízható állításához használja a toBeCloseTo állítást.

toBeCloseTo

• Típus: (value: number, numDigits?: number) => Awaitable<void>

Használja a toBeCloseTo függvényt lebegőpontos számok összehasonlítására. Az opcionális numDigits argumentum korlátozza az ellenőrizendő számjegyek számát a tizedesvessző után. Például:

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

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

• Típus: () => Awaitable<void>

A toBeDefined ellenőrzi, hogy az érték nem undefined. Hasznos annak ellenőrzésére, hogy egy függvény visszaadott-e értéket.

import { expect, test } from 'vitest';

function getApples() {
  return 3;
}

test('function returned something', () => {
  expect(getApples()).toBeDefined();
});

toBeUndefined

• Típus: () => Awaitable<void>

A toBeDefined ellentéte, a toBeUndefined ellenőrzi, hogy az érték undefined. Hasznos annak ellenőrzésére, hogy egy függvény nem adott-e vissza értéket.

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

• Típus: () => Awaitable<void>

A toBeTruthy ellenőrzi, hogy az érték igazra konvertálható-e. Hasznos, ha nem az érték a lényeg, hanem csak az, hogy true-vá konvertálható-e.

Például, ha az alábbi kóddal dolgozik, nem az stocks.getInfo visszatérési értéke a fontos – lehet egy komplex objektum, egy string, vagy bármi más. A kód továbbra is működni fog.

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

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

Tehát ha azt szeretné tesztelni, hogy a stocks.getInfo truthy értéket ad vissza, írhatja:

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

A JavaScriptben minden truthy, kivéve a false, null, undefined, NaN, 0, -0, 0n, "" és document.all.

toBeFalsy

• Típus: () => Awaitable<void>

A toBeFalsy ellenőrzi, hogy az érték hamisra konvertálható-e. Hasznos, ha nem az érték a lényeg, hanem csak az, hogy false-vá konvertálható-e.

Például, ha az alábbi kóddal dolgozik, nem az stocks.stockFailed visszatérési értéke a fontos – bármilyen hamis értéket visszaadhat, de a kód továbbra is működni fog.

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

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

Tehát ha azt szeretné tesztelni, hogy a stocks.stockFailed falsy lesz, írhatja:

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

A JavaScriptben minden truthy, kivéve a false, null, undefined, NaN, 0, -0, 0n, "" és document.all.

toBeNull

• Típus: () => Awaitable<void>

A toBeNull egyszerűen ellenőrzi, hogy valami null. Alias a .toBe(null)-hoz.

import { expect, test } from 'vitest';

function apples() {
  return null;
}

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

toBeNaN

• Típus: () => Awaitable<void>

A toBeNaN egyszerűen ellenőrzi, hogy valami NaN. Alias a .toBe(NaN)-hoz.

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

toBeOneOf

• Típus: (sample: Array<any>) => any

A toBeOneOf ellenőrzi, hogy egy érték megegyezik-e a megadott tömbben lévő értékek bármelyikével.

import { expect, test } from 'vitest';

test('fruit is one of the allowed values', () => {
  expect(fruit).toBeOneOf(['apple', 'banana', 'orange']);
});

Az aszimmetrikus matcher különösen hasznos az opcionális tulajdonságok tesztelésénél, amelyek null vagy undefined értékűek lehetnek:

test('optional properties can be null or undefined', () => {
  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

Ezzel a matcherrel használhatja az expect.not függvényt, hogy biztosítsa, hogy egy érték ne egyezzen meg a megadott opciók egyikével sem.

toBeTypeOf

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

A toBeTypeOf ellenőrzi, hogy egy tényleges érték a megadott típusú-e.

import { expect, test } from 'vitest';

const actual = 'stock';

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

toBeInstanceOf

• Típus: (c: any) => Awaitable<void>

A toBeInstanceOf ellenőrzi, hogy egy tényleges érték a megadott osztály példánya-e.

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

• Típus: (n: number | bigint) => Awaitable<void>

A toBeGreaterThan ellenőrzi, hogy a tényleges érték nagyobb-e a megadottnál. Az egyenlő értékek sikertelen teszthez vezetnek.

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

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

toBeGreaterThanOrEqual

• Típus: (n: number | bigint) => Awaitable<void>

A toBeGreaterThanOrEqual ellenőrzi, hogy a tényleges érték nagyobb-e a megadottnál, vagy egyenlő-e vele.

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

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

toBeLessThan

• Típus: (n: number | bigint) => Awaitable<void>

A toBeLessThan ellenőrzi, hogy a tényleges érték kisebb-e a megadottnál. Az egyenlő értékek sikertelen teszthez vezetnek.

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

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

toBeLessThanOrEqual

• Típus: (n: number | bigint) => Awaitable<void>

A toBeLessThanOrEqual ellenőrzi, hogy a tényleges érték kisebb-e a megadottnál, vagy egyenlő-e vele.

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

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

toEqual

• Típus: (received: any) => Awaitable<void>

A toEqual ellenőrzi, hogy a tényleges érték egyenlő-e a megadottal, vagy azonos struktúrájú-e, ha objektum (rekurzívan hasonlítja össze őket). A toEqual és a toBe közötti különbséget az alábbi példa szemlélteti:

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 objektumok esetén a nem számozható tulajdonságok, mint például a name, message, cause és AggregateError.errors is összehasonlításra kerülnek. Az Error.cause esetében az összehasonlítás aszimmetrikusan történik:

// siker
expect(new Error('hi', { cause: 'x' })).toEqual(new Error('hi'));

// hiba
expect(new Error('hi')).toEqual(new Error('hi', { cause: 'x' }));

Annak teszteléséhez, hogy dobott-e hibát, használja a toThrowError állítást.

toStrictEqual

• Típus: (received: any) => Awaitable<void>

A toStrictEqual ellenőrzi, hogy a tényleges érték egyenlő-e a megadottal, vagy azonos struktúrájú-e, ha objektum (rekurzívan hasonlítja össze őket), és azonos típusú.

Különbségek a .toEqual függvénytől:

• Az undefined tulajdonságokkal rendelkező kulcsok ellenőrzésre kerülnek. pl. {a: undefined, b: 2} nem egyezik meg {b: 2}-vel a .toStrictEqual használatakor.
• A tömb ritka elemei (pl. üres helyek) ellenőrzésre kerülnek. pl. [, 1] nem egyezik meg [undefined, 1]-gyel a .toStrictEqual használatakor.
• Az objektumtípusok egyenlőségét ellenőrzik. pl. Egy a és b mezőkkel rendelkező osztálypéldány nem lesz egyenlő egy a és b mezőkkel rendelkező literális objektummal.

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

• Típus: (received: string) => Awaitable<void>

A toContain ellenőrzi, hogy a tényleges érték szerepel-e egy tömbben. A toContain azt is ellenőrizheti, hogy egy string egy másik string részkarakterlánca-e. Ha böngészőhöz hasonló környezetben futtatja a teszteket, ez az állítás azt is ellenőrizheti, hogy egy osztály szerepel-e egy classList-ben, vagy egy elem egy másikban.

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

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

  const element = document.querySelector('#el');
  // az elemnek van egy osztálya
  expect(element.classList).toContain('flex');
  // az elem egy másikban van
  expect(document.querySelector('#wrapper')).toContain(element);
});

toContainEqual

• Típus: (received: any) => Awaitable<void>

A toContainEqual ellenőrzi, hogy egy adott struktúrájú és értékű elem szerepel-e egy tömbben. Minden elemre hasonlóan működik, mint a toEqual.

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

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

toHaveLength

• Típus: (received: number) => Awaitable<void>

A toHaveLength ellenőrzi, hogy egy objektumnak van-e .length tulajdonsága, és az egy bizonyos numerikus értékre van-e beállítva.

import { expect, test } from 'vitest';

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

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

toHaveProperty

• Típus: (key: any, received?: any) => Awaitable<void>

A toHaveProperty ellenőrzi, hogy egy objektumhoz létezik-e tulajdonság a megadott key referenciánál.

Megadhat egy opcionális érték argumentumot is, amelyet mély egyenlőségnek is neveznek, mint a toEqual matcher, a kapott tulajdonság értékének összehasonlításához.

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 Invoice', () => {
  expect(invoice).toHaveProperty('isActive'); // állítás, hogy a kulcs létezik
  expect(invoice).toHaveProperty('total_amount', 5000); // állítás, hogy a kulcs létezik és az érték egyenlő

  expect(invoice).not.toHaveProperty('account'); // állítás, hogy ez a kulcs nem létezik

  // Mély hivatkozás pontjelöléssel
  expect(invoice).toHaveProperty('customer.first_name');
  expect(invoice).toHaveProperty('customer.last_name', 'Doe');
  expect(invoice).not.toHaveProperty('customer.location', 'India');

  // Mély hivatkozás a kulcsot tartalmazó tömb használatával
  expect(invoice).toHaveProperty('items[0].type', 'apples');
  expect(invoice).toHaveProperty('items.0.type', 'apples'); // a pontjelölés is működik

  // Mély hivatkozás a kulcsútvonalat tartalmazó tömb használatával
  expect(invoice).toHaveProperty(['items', 0, 'type'], 'apples');
  expect(invoice).toHaveProperty(['items', '0', 'type'], 'apples'); // a string jelölés is működik

  // Csomagolja a kulcsot egy tömbbe, hogy elkerülje a kulcs mély hivatkozásként való értelmezését
  expect(invoice).toHaveProperty(['P.O'], '12345');
});

toMatch

• Típus: (received: string | regexp) => Awaitable<void>

A toMatch ellenőrzi, hogy egy string megegyezik-e egy reguláris kifejezéssel vagy egy stringgel.

import { expect, test } from 'vitest';

test('top fruits', () => {
  expect('top fruits include apple, orange and grape').toMatch(/apple/);
  expect('applefruits').toMatch('fruit'); // a toMatch stringet is elfogad
});

toMatchObject

• Típus: (received: object | array) => Awaitable<void>

A toMatchObject ellenőrzi, hogy egy objektum megegyezik-e egy objektum tulajdonságainak egy részhalmazával.

Objektumok tömbje is átadható. Ez akkor hasznos, ha ellenőrizni szeretné, hogy két tömb elemeinek száma megegyezik-e, ellentétben az arrayContaining függvénnyel, amely extra elemeket engedélyez a kapott tömbben.

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('invoice has john personal details', () => {
  expect(johnInvoice).toMatchObject(johnDetails);
});

test('the number of elements must match exactly', () => {
  // Állítás, hogy egy objektumtömb megegyezik
  expect([{ foo: 'bar' }, { baz: 1 }]).toMatchObject([
    { foo: 'bar' },
    { baz: 1 },
  ]);
});

toThrowError

• Típus: (received: any) => Awaitable<void>

• Alias: toThrow

A toThrowError ellenőrzi, hogy egy függvény hibát dob-e, amikor meghívják.

Megadhat egy opcionális argumentumot is, hogy tesztelje, hogy egy adott hiba dobódik-e:

• RegExp: a hibaüzenet megegyezik a mintával
• string: a hibaüzenet tartalmazza az alstringet
• Error, AsymmetricMatcher: összehasonlítás egy kapott objektummal, hasonlóan a toEqual(received)-hez

TIP

A kódot egy függvénybe kell csomagolnia, különben a hiba nem kerül elkapásra, és a teszt sikertelen lesz.

Ez nem vonatkozik az aszinkron hívásokra, mivel a rejects helyesen bontja ki az ígéretet:

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

Például, ha azt szeretnénk tesztelni, hogy a getFruitStock('pineapples') hibát dob, írhatjuk:

import { expect, test } from 'vitest';

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

  // Do some other stuff
}

test('throws on pineapples', () => {
  // Tesztelje, hogy a hibaüzenet valahol tartalmazza a "stock" szót: ezek egyenértékűek
  expect(() => getFruitStock('pineapples')).toThrowError(/stock/);
  expect(() => getFruitStock('pineapples')).toThrowError('stock');

  // Tesztelje a pontos hibaüzenetet
  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

Aszinkron függvények teszteléséhez használja a rejects kombinációjával.

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

test('throws on pineapples', async () => {
  await expect(() => getAsyncFruitStock()).rejects.toThrowError('empty');
});

toMatchSnapshot

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

Ez ellenőrzi, hogy egy érték megegyezzen a legutóbbi pillanatképpel.

Megadhat egy opcionális hint string argumentumot, amely a teszt nevéhez hozzáadódik. Bár a Vitest mindig hozzáad egy számot a pillanatkép nevének végéhez, a rövid, leíró tippek hasznosabbak lehetnek a számoknál, hogy megkülönböztessék a több pillanatképet egymástól egyetlen it vagy test blokkban. A Vitest a pillanatképeket név szerint rendezi a megfelelő .snap fájlban.

TIP

Ha egy pillanatkép nem egyezik, és a teszt sikertelen lesz, ha az eltérés várható, nyomja meg az u billentyűt a pillanatkép egyszeri frissítéséhez. Vagy átadhatja a -u vagy --update CLI opciókat, hogy a Vitest mindig frissítse a teszteket.

import { expect, test } from 'vitest';

test('matches snapshot', () => {
  const data = { foo: new Set(['bar', 'snapshot']) };
  expect(data).toMatchSnapshot();
});

Megadhat egy objektum alakját (shape) is, ha csak egy objektum alakját teszteli, és nem kell 100%-ban kompatibilisnek lennie:

import { expect, test } from 'vitest';

test('matches snapshot', () => {
  const data = { foo: new Set(['bar', 'snapshot']) };
  expect(data).toMatchSnapshot({ foo: expect.any(Set) });
});

toMatchInlineSnapshot

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

Ez ellenőrzi, hogy egy érték megegyezzen a legutóbbi pillanatképpel.

A Vitest hozzáadja és frissíti az inlineSnapshot string argumentumot a matcherhez a tesztfájlban (külső .snap fájl helyett).

import { expect, test } from 'vitest';

test('matches inline snapshot', () => {
  const data = { foo: new Set(['bar', 'snapshot']) };
  // A Vitest frissíti a következő tartalmat a pillanatkép frissítésekor
  expect(data).toMatchInlineSnapshot(`
    {
      "foo": Set {
        "bar",
        "snapshot",
      },
    }
  `);
});

Megadhat egy objektum alakját (shape) is, ha csak egy objektum alakját teszteli, és nem kell 100%-ban kompatibilisnek lennie:

import { expect, test } from 'vitest';

test('matches snapshot', () => {
  const data = { foo: new Set(['bar', 'snapshot']) };
  expect(data).toMatchInlineSnapshot(
    { foo: expect.any(Set) },
    `
    {
      "foo": Any<Set>,
    }
  `
  );
});

toMatchFileSnapshot

• Típus: <T>(filepath: string, hint?: string) => Promise<void>

Hasonlítsa össze vagy frissítse a pillanatképet egy explicit módon megadott fájl tartalmával (a .snap fájl helyett).

import { expect, it } from 'vitest';

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

Vegye figyelembe, hogy mivel a fájlrendszer művelete aszinkron, az await kulcsszót kell használnia a toMatchFileSnapshot() függvénnyel. Ha az await nincs használva, a Vitest úgy kezeli, mint az expect.soft, ami azt jelenti, hogy az utasítás utáni kód tovább fut, még akkor is, ha a pillanatképben eltérés van. Miután a teszt befejeződött, a Vitest ellenőrzi a pillanatképet, és sikertelen lesz, ha eltérés van.

toThrowErrorMatchingSnapshot

• Típus: (hint?: string) => void

Ugyanaz, mint a toMatchSnapshot, de ugyanazt az értéket várja, mint a toThrowError.

toThrowErrorMatchingInlineSnapshot

• Típus: (snapshot?: string, hint?: string) => void

Ugyanaz, mint a toMatchInlineSnapshot, de ugyanazt az értéket várja, mint a toThrowError.

toHaveBeenCalled

• Típus: () => Awaitable<void>

Ez az állítás arra használható, hogy tesztelje, meghívtak-e egy függvényt. Egy spy függvényt kell átadni az expect-nek.

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

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

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

  expect(buySpy).not.toHaveBeenCalled();

  market.buy('apples', 10);

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

toHaveBeenCalledTimes

• Típus: (amount: number) => Awaitable<void>

Ez az állítás ellenőrzi, hogy egy függvényt hányszor hívták meg. Egy spy függvényt kell átadni az expect-nek.

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

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

test('spy function called two times', () => {
  const buySpy = vi.spyOn(market, 'buy');

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

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

toHaveBeenCalledWith

• Típus: (...args: any[]) => Awaitable<void>

Ez az állítás ellenőrzi, hogy egy függvényt legalább egyszer meghívták-e bizonyos paraméterekkel. Egy spy függvényt kell átadni az expect-nek.

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

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

test('spy function', () => {
  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ípus: (mock: MockInstance, failIfNoFirstInvocation?: boolean) => Awaitable<void>

Ez az állítás ellenőrzi, hogy egy Mock függvényt egy másik Mock függvény előtt hívták-e meg.

test('calls mock1 before mock2', () => {
  const mock1 = vi.fn();
  const mock2 = vi.fn();

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

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

toHaveBeenCalledAfter 3.0.0+

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

Ez az állítás ellenőrzi, hogy egy Mock függvényt egy másik Mock függvény után hívták-e meg.

test('calls mock1 after mock2', () => {
  const mock1 = vi.fn();
  const mock2 = vi.fn();

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

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

toHaveBeenCalledExactlyOnceWith 3.0.0+

• Típus: (...args: any[]) => Awaitable<void>

Ez az állítás ellenőrzi, hogy egy függvényt pontosan egyszer és bizonyos paraméterekkel hívták-e meg. Egy spy függvényt kell átadni az expect-nek.

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

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

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

  market.buy('apples', 10);

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

toHaveBeenLastCalledWith

• Típus: (...args: any[]) => Awaitable<void>

Ez az állítás ellenőrzi, hogy egy függvényt bizonyos paraméterekkel hívták-e meg az utolsó hívásakor. Egy spy függvényt kell átadni az expect-nek.

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

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

test('spy function', () => {
  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ípus: (time: number, ...args: any[]) => Awaitable<void>

Ez az állítás ellenőrzi, hogy egy függvényt bizonyos paraméterekkel hívták-e meg egy adott időpontban. A számlálás 1-től kezdődik. Tehát a második bejegyzés ellenőrzéséhez a .toHaveBeenNthCalledWith(2, ...)-t kell írnia.

Egy spy függvényt kell átadni az expect-nek.

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

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

test('first call of spy function called with right params', () => {
  const buySpy = vi.spyOn(market, 'buy');

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

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

toHaveReturned

• Típus: () => Awaitable<void>

Ez az állítás ellenőrzi, hogy egy függvény legalább egyszer sikeresen visszaadott-e egy értéket (azaz nem dobott hibát). Egy spy függvényt kell átadni az expect-nek.

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

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

test('spy function returned a value', () => {
  const getPriceSpy = vi.fn(getApplesPrice);

  const price = getPriceSpy(10);

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

toHaveReturnedTimes

• Típus: (amount: number) => Awaitable<void>

Ez az állítás ellenőrzi, hogy egy függvény pontosan hányszor adott vissza sikeresen egy értéket (azaz nem dobott hibát). Egy spy függvényt kell átadni az expect-nek.

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

test('spy function returns a value two times', () => {
  const sell = vi.fn((product: string) => ({ product }));

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

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

toHaveReturnedWith

• Típus: (returnValue: any) => Awaitable<void>

Ezt az állítást meghívhatja annak ellenőrzésére, hogy egy függvény legalább egyszer sikeresen visszaadott-e egy értéket bizonyos paraméterekkel. Egy spy függvényt kell átadni az expect-nek.

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

test('spy function returns a product', () => {
  const sell = vi.fn((product: string) => ({ product }));

  sell('apples');

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

toHaveLastReturnedWith

• Típus: (returnValue: any) => Awaitable<void>

Ezt az állítást meghívhatja annak ellenőrzésére, hogy egy függvény sikeresen visszaadott-e egy bizonyos értéket az utolsó hívásakor. Egy spy függvényt kell átadni az expect-nek.

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

test('spy function returns bananas on a last call', () => {
  const sell = vi.fn((product: string) => ({ product }));

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

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

toHaveNthReturnedWith

• Típus: (time: number, returnValue: any) => Awaitable<void>

Ezt az állítást meghívhatja annak ellenőrzésére, hogy egy függvény sikeresen visszaadott-e egy értéket bizonyos paraméterekkel egy adott híváskor. Egy spy függvényt kell átadni az expect-nek.

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

test('spy function returns bananas on second call', () => {
  const sell = vi.fn((product: string) => ({ product }));

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

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

toHaveResolved

• Típus: () => Awaitable<void>

Ez az állítás ellenőrzi, hogy egy függvény legalább egyszer sikeresen feloldott-e egy értéket (azaz nem utasított el). Egy spy függvényt kell átadni az expect-nek.

Ha a függvény egy ígéretet adott vissza, de az még nem oldódott fel, ez sikertelen lesz.

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

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

test('spy function resolved a value', async () => {
  const getPriceSpy = vi.fn(getApplesPrice);

  const price = await getPriceSpy(10);

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

toHaveResolvedTimes

• Típus: (amount: number) => Awaitable<void>

Ez az állítás ellenőrzi, hogy egy függvény pontosan hányszor oldott fel sikeresen egy értéket (azaz nem utasított el). Egy spy függvényt kell átadni az expect-nek.

Ez csak a feloldott ígéreteket számolja meg. Ha a függvény egy ígéretet adott vissza, de az még nem oldódott fel, akkor nem kerül megszámolásra.

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

test('spy function resolved a value two times', async () => {
  const sell = vi.fn((product: string) => Promise.resolve({ product }));

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

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

toHaveResolvedWith

• Típus: (returnValue: any) => Awaitable<void>

Ezt az állítást meghívhatja annak ellenőrzésére, hogy egy függvény legalább egyszer sikeresen feloldott-e egy bizonyos értéket. Egy spy függvényt kell átadni az expect-nek.

Ha a függvény egy ígéretet adott vissza, de az még nem oldódott fel, ez sikertelen lesz.

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

test('spy function resolved a product', async () => {
  const sell = vi.fn((product: string) => Promise.resolve({ product }));

  await sell('apples');

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

toHaveLastResolvedWith

• Típus: (returnValue: any) => Awaitable<void>

Ezt az állítást meghívhatja annak ellenőrzésére, hogy egy függvény sikeresen feloldott-e egy bizonyos értéket az utolsó hívásakor. Egy spy függvényt kell átadni az expect-nek.

Ha a függvény egy ígéretet adott vissza, de az még nem oldódott fel, ez sikertelen lesz.

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

test('spy function resolves bananas on a last call', async () => {
  const sell = vi.fn((product: string) => Promise.resolve({ product }));

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

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

toHaveNthResolvedWith

• Típus: (time: number, returnValue: any) => Awaitable<void>

Ezt az állítást meghívhatja annak ellenőrzésére, hogy egy függvény sikeresen feloldott-e egy bizonyos értéket egy adott híváskor. Egy spy függvényt kell átadni az expect-nek.

Ha a függvény egy ígéretet adott vissza, de az még nem oldódott fel, ez sikertelen lesz.

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

test('spy function returns bananas on second call', async () => {
  const sell = vi.fn((product: string) => Promise.resolve({ product }));

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

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

toSatisfy

• Típus: (predicate: (value: any) => boolean) => Awaitable<void>

Ez az állítás ellenőrzi, hogy egy érték kielégít-e egy bizonyos predikátumot.

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

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

describe('toSatisfy()', () => {
  it('pass with 0', () => {
    expect(1).toSatisfy(isOdd);
  });

  it('pass with negation', () => {
    expect(2).not.toSatisfy(isOdd);
  });
});

resolves

• Típus: Promisify<Assertions>

A resolves célja a boilerplate kód eltávolítása az aszinkron kód állításakor. Használja a függő ígéret értékének kibontására és értékének ellenőrzésére a szokásos állításokkal. Ha az ígéret elutasítódik, az állítás sikertelen lesz.

Ugyanazt az Assertions objektumot adja vissza, de mostantól minden matcher Promise-t ad vissza, így await-elni kell. A chai állításokkal is működik.

Például, ha van egy függvénye, amely API hívást kezdeményez és adatokat ad vissza, ezt a kódot használhatja a visszatérési érték állítására:

import { expect, test } from 'vitest';

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

test('buyApples returns new stock id', async () => {
  // a toEqual most promise-t ad vissza, ezért KÖTELEZŐ megvárni
  await expect(buyApples()).resolves.toEqual({ id: 1 }); // jest API
  await expect(buyApples()).resolves.to.equal({ id: 1 }); // chai API
});

WARNING

Ha az állítás nincs megvárva, akkor egy hamis pozitív tesztet eredményez, amely minden alkalommal sikeres lesz. Annak biztosítására, hogy az állítások ténylegesen meghívásra kerüljenek, használhatja az expect.assertions(number) függvényt.

A Vitest 3 óta, ha egy metódus nincs megvárva, a Vitest figyelmeztetést jelenít meg a teszt végén. A Vitest 4-ben a teszt "sikertelen" állapotba kerül, ha az állítás nincs megvárva.

rejects

• Típus: Promisify<Assertions>

A rejects célja a boilerplate kód eltávolítása az aszinkron kód állításakor. Használja az ígéret elutasításának okának kibontására és értékének ellenőrzésére a szokásos állításokkal. Ha az ígéret sikeresen feloldódik, az állítás sikertelen lesz.

Ugyanazt az Assertions objektumot adja vissza, de mostantól minden matcher Promise-t ad vissza, így await-elni kell. A chai állításokkal is működik.

Például, ha van egy függvénye, amely hibát dob, amikor meghívja, ezt a kódot használhatja az ok állítására:

import { expect, test } from 'vitest';

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

test('buyApples throws an error when no id provided', async () => {
  // a toThrow most promise-t ad vissza, ezért KÖTELEZŐ megvárni
  await expect(buyApples()).rejects.toThrow('no id');
});

WARNING

Ha az állítás nincs megvárva, akkor egy hamis pozitív tesztet eredményez, amely minden alkalommal sikeres lesz. Annak biztosítására, hogy az állítások ténylegesen meghívásra kerüljenek, használhatja az expect.assertions(number) függvényt.

A Vitest 3 óta, ha egy metódus nincs megvárva, a Vitest figyelmeztetést jelenít meg a teszt végén. A Vitest 4-ben a teszt "sikertelen" állapotba kerül, ha az állítás nincs megvárva.

expect.assertions

• Típus: (count: number) => void

Miután a teszt sikeresen lefutott vagy sikertelen lett, ellenőrizze, hogy a teszt során bizonyos számú állítást meghívtak-e. Hasznos eset lehet annak ellenőrzése, hogy egy aszinkron kódot meghívtak-e.

Például, ha van egy függvényünk, amely aszinkron módon hív meg két matchert, állíthatjuk, hogy azok ténylegesen meghívásra kerültek.

import { expect, test } from 'vitest';

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

test('all assertions are called', async () => {
  expect.assertions(2);
  function callback1(data) {
    expect(data).toBeTruthy();
  }
  function callback2(data) {
    expect(data).toBeTruthy();
  }

  await doAsync(callback1, callback2);
});

WARNING

Aszinkron, párhuzamos tesztek használatakor a helyi Teszt Kontextusból származó expect függvényt kell használni a megfelelő teszt azonosításának biztosításához.

expect.hasAssertions

• Típus: () => void

Miután a teszt sikeresen lefutott vagy sikertelen lett, ellenőrizze, hogy legalább egy állítást meghívtak-e a teszt során. Hasznos eset lehet annak ellenőrzése, hogy egy aszinkron kódot meghívtak-e.

Például, ha van egy kódunk, amely visszahívást hív meg, elhelyezhetünk egy állítást a visszahíváson belül, de a teszt mindig sikeres lesz, ha nem ellenőrizzük, hogy egy állítást meghívtak-e.

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

const cbs = [];

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

// az adatbázisból való kiválasztás után meghívjuk az összes visszahívást
function select(id) {
  return db.select({ id }).then(data => {
    return Promise.all(cbs.map(cb => cb(data)));
  });
}

test('callback was called', async () => {
  expect.hasAssertions();
  onSelect(data => {
    // kiválasztáskor meg kell hívni
    expect(data).toBeTruthy();
  });
  // ha nem awaited, test will fail
  // if you don't have expect.hasAssertions(), test will pass
  await select(3);
});

expect.unreachable

• Típus: (message?: string) => never

Ez a metódus annak ellenőrzésére szolgál, hogy egy sor soha nem érhető el.

Például, ha azt szeretnénk tesztelni, hogy a build() hibát dob, mert a fogadó könyvtárakban nincs src mappa, és minden hibát külön-külön kezelni szeretnénk, akkor az alábbi módon járhatunk el:

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 fails with "%s"', async dir => {
  try {
    await build(dir);
    expect.unreachable('Should not pass build');
  } 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:
        // az összes hibateszt kimerítéséhez
        expect.unreachable('All error test must be handled');
        break;
    }
  }
});

expect.anything

• Típus: () => any

Ez az aszimmetrikus matcher, ha egyenlőségellenőrzéssel használják, mindig true értéket ad vissza. Hasznos, ha csak arról szeretne meggyőződni, hogy a tulajdonság létezik-e.

import { expect, test } from 'vitest';

test('object has "apples" key', () => {
  expect({ apples: 22 }).toEqual({ apples: expect.anything() });
});

expect.any

• Típus: (constructor: unknown) => any

Ez az aszimmetrikus matcher, ha egyenlőségellenőrzéssel használják, csak akkor ad vissza true értéket, ha az érték egy megadott konstruktor példánya. Hasznos, ha van egy értéke, amelyet minden alkalommal generálnak, és csak azt szeretné tudni, hogy megfelelő típussal létezik-e.

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

test('"id" is a number', () => {
  expect({ id: generateId() }).toEqual({ id: expect.any(Number) });
});

expect.closeTo

• Típus: (expected: any, precision?: number) => any

Az expect.closeTo hasznos lebegőpontos számok összehasonlításakor objektumok tulajdonságaiban vagy tömbelemekben. Ha egy számot kell összehasonlítania, használja helyette a .toBeCloseTo függvényt.

Az opcionális precision argumentum korlátozza a tizedesvessző után ellenőrzendő számjegyek számát. Az alapértelmezett 2 érték esetén a tesztkritérium Math.abs(expected - received) < 0.005 (azaz 10 ** -2 / 2).

Például ez a teszt 5 számjegy pontossággal sikeres:

test('compare float in object properties', () => {
  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ípus: <T>(expected: T[]) => any

Ha egyenlőségellenőrzéssel használják, ez az aszimmetrikus matcher true értéket ad vissza, ha az érték egy tömb, és tartalmazza a megadott elemeket.

import { expect, test } from 'vitest';

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

TIP

Ezzel a matcherrel használhatja az expect.not függvényt a várt érték negálására.

expect.objectContaining

• Típus: (expected: any) => any

Ha egyenlőségellenőrzéssel használják, ez az aszimmetrikus matcher true értéket ad vissza, ha az érték hasonló alakú.

import { expect, test } from 'vitest';

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

TIP

Ezzel a matcherrel használhatja az expect.not függvényt a várt érték negálására.

expect.stringContaining

• Típus: (expected: any) => any

Ha egyenlőségellenőrzéssel használják, ez az aszimmetrikus matcher true értéket ad vissza, ha az érték egy string, és tartalmaz egy megadott alstringet.

import { expect, test } from 'vitest';

test('variety has "Emp" in its name', () => {
  const variety = {
    name: 'Empire',
    count: 1,
  };
  expect(variety).toEqual({
    name: expect.stringContaining('Emp'),
    count: 1,
  });
});

TIP

Ezzel a matcherrel használhatja az expect.not függvényt a várt érték negálására.

expect.stringMatching

• Típus: (expected: any) => any

Ha egyenlőségellenőrzéssel használják, ez az aszimmetrikus matcher true értéket ad vissza, ha az érték egy string, és tartalmaz egy megadott alstringet, vagy ha a string megegyezik egy reguláris kifejezéssel.

import { expect, test } from 'vitest';

test('variety ends with "re"', () => {
  const variety = {
    name: 'Empire',
    count: 1,
  };
  expect(variety).toEqual({
    name: expect.stringMatching(/re$/),
    count: 1,
  });
});

TIP

Ezzel a matcherrel használhatja az expect.not függvényt a várt érték negálására.

expect.addSnapshotSerializer

• Típus: (plugin: PrettyFormatPlugin) => void

Ez a metódus egyéni szerializálókat ad hozzá, amelyeket a pillanatkép létrehozásakor meghívnak. Ez egy haladó funkció. Ha többet szeretne tudni, olvassa el az egyéni szerializálókról szóló útmutatót.

Ha egyéni szerializálókat ad hozzá, ezt a metódust a setupFiles fájlban kell meghívnia. Ez minden pillanatképet érinteni fog.

TIP

Ha korábban Vue CLI-t használt Jesttel, érdemes telepítenie a jest-serializer-vue csomagot. Ellenkező esetben a pillanatképek egy stringbe lesznek csomagolva, ami a " karakterek escape-elését okozza.

expect.extend

• Típus: (matchers: MatchersObject) => void

Kiterjesztheti az alapértelmezett matchereket sajátjaival. Ez a függvény a matcher objektum kiterjesztésére szolgál egyéni matcherekkel.

Amikor így definiál matchereket, aszimmetrikus matchereket is létrehoz, amelyek használhatók, mint az expect.stringContaining.

import { expect, test } from 'vitest';

test('custom matchers', () => {
  expect.extend({
    toBeFoo: (received, expected) => {
      if (received !== 'foo') {
        return {
          message: () => `expected ${received} to be foo`,
          pass: false,
        };
      }
    },
  });

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

TIP

Ha azt szeretné, hogy a matcherei minden tesztben megjelenjenek, ezt a metódust a setupFiles fájlban kell meghívnia.

Ez a függvény kompatibilis a Jest expect.extend függvényével, így bármely könyvtár, amely ezt használja egyéni matcherek létrehozására, működni fog a Vitesttel.

Ha TypeScriptet használ, a Vitest 0.31.0 óta kiterjesztheti az alapértelmezett Assertion interfészt egy környezeti deklarációs fájlban (pl. vitest.d.ts) az alábbi kóddal:

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

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

WARNING

Ne felejtse el belefoglalni a környezeti deklarációs fájlt a tsconfig.json fájlba.

TIP

Ha többet szeretne tudni, nézze meg az illesztők kiterjesztéséről szóló útmutatót.

expect.addEqualityTesters

• Típus: (tester: Array<Tester>) => void

Ezt a metódust használhatja egyéni tesztelők definiálására, amelyek olyan metódusok, amelyeket a matcherek használnak két objektum egyenlőségének tesztelésére. Kompatibilis a Jest expect.addEqualityTesters metódusával.

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('custom equality tester', () => {
  expect(new AnagramComparator('listen')).toEqual(
    new AnagramComparator('silent')
  );
});