Teszt API Dokumentáció

A következő típusok használatosak az alábbi típusdefiníciókban:

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

interface TestOptions {
  /**
   * A teszt sikertelen lesz, ha a végrehajtása túl sokáig tart.
   */
  timeout?: number;
  /**
   * A teszt sikertelenség esetén adott alkalommal újrapróbálkozik.
   *
   * @default 0
   */
  retry?: number;
  /**
   * Ugyanazt a tesztet többször megismétli, még akkor is, ha az minden alkalommal sikertelen.
   * Ha a "retry" opció be van állítva, és a teszt sikertelen, akkor minden ciklusban felhasználja az összes újrapróbálkozást.
   * Hasznos a véletlenszerű hibák felderítéséhez.
   *
   * @default 0
   */
  repeats?: number;
}

Ha egy teszt függvény egy promise-t ad vissza, a futtató vár, amíg az befejeződik, hogy összegyűjtse az aszinkron elvárásokat. Ha a promise elutasításra kerül, a teszt sikertelen lesz.

TIP

A Jest esetében a TestFunction típusa lehet (done: DoneCallback) => void is. Ha ez a forma használatos, a teszt nem fejeződik be, amíg a done függvényt meg nem hívják. Ugyanezt elérheted egy async függvénnyel is, lásd a Migrációs útmutató Done Callback szekcióját.

test

Típus: (name: string | Function, fn: TestFunction, timeout?: number | TestOptions) => void
Alias: it
A test egy kapcsolódó elvárás-halmazt definiál. Fogadja a teszt nevét és egy függvényt, ami a tesztelendő elvárásokat tartalmazza.
Opcionálisan megadhatsz egy időtúllépési értéket (milliszekundumban), amely meghatározza, hogy mennyi ideig kell várni a teszt leállításáig. Az alapértelmezett érték 5 másodperc, és globálisan konfigurálható a testTimeout segítségével.
ts
```
import { expect, test } from 'vitest';

test('should work as expected', () => {
  expect(Math.sqrt(4)).toBe(2);
});
```

test.extend

Típus: <T extends Record<string, any>>(fixtures: Fixtures<T>): TestAPI<ExtraContext & T>
Alias: it.extend

Verzió: Vitest 0.32.3

A test.extend metódussal kiegészítheted a tesztkörnyezetet egyedi fixture-ökkel. Ez egy új test függvényt ad vissza, ami szintén kiegészíthető, így további fixture-öket adhatsz hozzá, vagy felülírhatod a meglévőket a szükségleteid szerint. További információkért lásd a Tesztkörnyezet kiegészítése részt.

import { expect, test } from 'vitest';

const todos = [];
const archive = [];

const myTest = test.extend({
  todos: async ({ task }, use) => {
    todos.push(1, 2, 3);
    await use(todos);
    todos.length = 0;
  },
  archive,
});

myTest('add item', ({ todos }) => {
  expect(todos.length).toBe(3);

  todos.push(4);
  expect(todos.length).toBe(4);
});

test.skip

Típus: (name: string | Function, fn: TestFunction, timeout?: number | TestOptions) => void

Alias: it.skip

Ha bizonyos teszteket ki szeretnél hagyni, de valamilyen okból nem akarod törölni a kódot, használhatod a test.skip metódust a futtatásuk megakadályozására.

import { assert, test } from 'vitest';

test.skip('skipped test', () => {
  // Test skipped, no error
  assert.equal(Math.sqrt(4), 3);
});

A tesztet dinamikusan is kihagyhatod, ha meghívod a környezetének skip metódusát.

import { assert, test } from 'vitest';

test('skipped test', context => {
  context.skip();
  // Test skipped, no error
  assert.equal(Math.sqrt(4), 3);
});

test.skipIf

Típus: (condition: any) => Test

Alias: it.skipIf

Ahelyett, hogy a tesztkódot if utasítással vennéd körül, a test.skipIf metódussal kihagyhatod a tesztet, ha a feltétel igaz.

import { assert, test } from 'vitest';

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

test.skipIf(isDev)('prod only test', () => {
  // this test only runs in production
});

WARNING

Ezt a szintaxist nem használhatod, ha a Vitest-et típusellenőrzőként használod.

test.runIf

Típus: (condition: any) => Test

Alias: it.runIf

A test.skipIf metódus ellentéte: csak akkor fut, ha a feltétel igaz.

import { assert, test } from 'vitest';

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

test.runIf(isDev)('dev only test', () => {
  // this test only runs in development
});

WARNING

Ezt a szintaxist nem használhatod, ha a Vitest-et típusellenőrzőként használod.

test.only

Típus: (name: string | Function, fn: TestFunction, timeout?: number) => void
Alias: it.only
A test.only metódussal csak bizonyos teszteket futtathatsz egy adott tesztfájlban. Ez hibakereséskor hasznos.
Opcionálisan megadhatsz egy időtúllépési értéket (milliszekundumban), amely meghatározza, hogy mennyi ideig kell várni a teszt leállításáig. Az alapértelmezett érték 5 másodperc, és globálisan konfigurálható a testTimeout segítségével.
ts
```
import { assert, test } from 'vitest';

test.only('test', () => {
  // Only this test (and others marked with only) are run
  assert.equal(Math.sqrt(4), 2);
});
```
Néha nagyon hasznos lehet, ha csak egy adott fájlban futtatod az only teszteket, figyelmen kívül hagyva az összes többi tesztet, amelyek zavarhatják a kimenetet.
Ehhez futtasd a vitest parancsot a kérdéses teszteket tartalmazó fájllal.
```
# vitest interesting.test.ts
```

test.concurrent

Típus: (name: string | Function, fn: TestFunction, timeout?: number) => void

Alias: it.concurrent

A test.concurrent metódus párhuzamosan futtatandó teszteket jelöl. Megkapja a teszt nevét, egy aszinkron függvényt a tesztekkel, valamint egy opcionális időkorlátot (milliszekundumban).

import { describe, test } from 'vitest';

// The two tests marked with concurrent will be run in parallel
describe('suite', () => {
  test('serial test', async () => {
    /* ... */
  });
  test.concurrent('concurrent test 1', async () => {
    /* ... */
  });
  test.concurrent('concurrent test 2', async () => {
    /* ... */
  });
});

A test.skip, test.only és test.todo működik a párhuzamos tesztekkel. Az alábbi kombinációk mindegyike érvényes:

test.concurrent(/* ... */);
test.skip.concurrent(/* ... */); // or test.concurrent.skip(/* ... */)
test.only.concurrent(/* ... */); // or test.concurrent.only(/* ... */)
test.todo.concurrent(/* ... */); // or test.concurrent.todo(/* ... */)

Párhuzamos tesztek futtatásakor a Pillanatképeknek és az Állításoknak a helyi Tesztkörnyezet expect metódusát kell használniuk, hogy biztosítsák a megfelelő teszt azonosítását.

test.concurrent('test 1', async ({ expect }) => {
  expect(foo).toMatchSnapshot();
});
test.concurrent('test 2', async ({ expect }) => {
  expect(foo).toMatchSnapshot();
});

WARNING

Ezt a szintaxist nem használhatod, ha a Vitest-et típusellenőrzőként használod.

test.todo

Típus: (name: string | Function) => void
Alias: it.todo
A test.todo metódussal létrehozhatod a később megvalósítandó tesztek helyőrzőit. A tesztekhez egy bejegyzés jelenik meg a jelentésben, így láthatod, hogy még hány tesztet kell megvalósítanod.
ts
```
// An entry will be shown in the report for this test
test.todo('unimplemented test');
```

test.fails

Típus: (name: string | Function, fn: TestFunction, timeout?: number) => void

Alias: it.fails

A test.fails metódussal jelezheted, hogy egy állítás várhatóan sikertelen lesz.

import { expect, test } from 'vitest';

function myAsyncFunc() {
  return new Promise(resolve => resolve(1));
}
test.fails('fail test', async () => {
  await expect(myAsyncFunc()).rejects.toBe(1);
});

WARNING

Ezt a szintaxist nem használhatod, ha a Vitest-et típusellenőrzőként használod.

test.each

Típus: (cases: ReadonlyArray<T>, ...args: any[]) => void

Alias: it.each

Használd a test.each metódust, ha ugyanazt a tesztet különböző bemeneti adatokkal szeretnéd futtatni. A teszt nevébe paramétereket injektálhatsz a printf formázással a tesztfüggvény paramétereinek sorrendjében.

%s: string
%d: szám
%i: egész szám
%f: lebegőpontos érték
%j: json
%o: objektum
%#: a teszteset indexe
%%: egyetlen százalékjel ('%')

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

// this will return
// ✓ add(1, 1) -> 2
// ✓ add(1, 2) -> 3
// ✓ add(2, 1) -> 3

Ha objektumokat használsz argumentumként, az objektumok tulajdonságaihoz a $ előtaggal is hozzáférhetsz.

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

// this will return
// ✓ add(1, 1) -> 2
// ✓ add(1, 2) -> 3
// ✓ add(2, 1) -> 3

Ha objektumokat használsz argumentumként, az objektumok attribútumaihoz a . segítségével is hozzáférhetsz.

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

// this will return
// ✓ add(1, b) -> 1b
// ✓ add(2, b) -> 2b
// ✓ add(3, b) -> 3b

A Vitest 0.25.3-tól kezdve sablon string táblázatot is használhatsz.

Az első sornak oszlopneveket kell tartalmaznia, | karakterrel elválasztva;
Egy vagy több további adatsor sablon literál kifejezésként megadva a ${value} szintaxissal.

test.each`
  a             | b      | expected
  ${1}          | ${1}   | ${2}
  ${'a'}        | ${'b'} | ${'ab'}
  ${[]}         | ${'b'} | ${'b'}
  ${{}}         | ${'b'} | ${'[object Object]b'}
  ${{ asd: 1 }} | ${'b'} | ${'[object Object]b'}
`('returns $expected when $a is added $b', ({ a, b, expected }) => {
  expect(a + b).toBe(expected);
});

Ha hozzá szeretnél férni a TestContext-hez, használd a describe.each metódust egyetlen teszttel.

TIP

A Vitest a $values értékeket a chai format metódusával dolgozza fel. Ha az érték túl csonka, növelheted a chaiConfig.truncateThreshold értékét a konfigurációs fájlban.

WARNING

Ezt a szintaxist nem használhatod, ha a Vitest-et típusellenőrzőként használod.

bench

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

A bench egy benchmarkot definiál. A Vitest szóhasználatában a benchmark egy olyan függvény, amely műveletek sorozatát határozza meg. A Vitest többször futtatja ezt a függvényt, hogy különböző teljesítménymutatókat mutasson.

A Vitest a háttérben a tinybench könyvtárat használja, örökölve annak összes opcióját, amelyek harmadik argumentumként használhatók.

import { bench } from 'vitest';

bench(
  'normal sorting',
  () => {
    const x = [1, 5, 4, 2, 3];
    x.sort((a, b) => {
      return a - b;
    });
  },
  { time: 1000 }
);

export interface Options {
  /**
   * A benchmark feladat futtatásához szükséges idő (milliszekundumban)
   * @default 500
   */
  time?: number;

  /**
   * A feladat futtatásának száma, még akkor is, ha az idő opció befejeződött
   * @default 10
   */
  iterations?: number;

  /**
   * Függvény az aktuális időbélyeg lekéréséhez milliszekundumban
   */
  now?: () => number;

  /**
   * Egy AbortSignal a benchmark megszakításához
   */
  signal?: AbortSignal;

  /**
   * Bemelegítési idő (milliszekundumban)
   * @default 100ms
   */
  warmupTime?: number;

  /**
   * Bemelegítési iterációk
   * @default 5
   */
  warmupIterations?: number;

  /**
   * Beállító függvény, amely minden benchmark feladat (ciklus) előtt fut
   */
  setup?: Hook;

  /**
   * Lebontó függvény, amely minden benchmark feladat (ciklus) után fut
   */
  teardown?: Hook;
}

bench.skip

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

A bench.skip szintaxissal kihagyhatod bizonyos benchmarkok futtatását.

import { bench } from 'vitest';

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

bench.only

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

A bench.only metódussal csak bizonyos benchmarkokat futtathatsz egy adott tesztfájlban. Ez hibakereséskor hasznos.

import { bench } from 'vitest';

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

bench.todo

Típus: (name: string | Function) => void

A bench.todo metódussal létrehozhatod a később megvalósítandó benchmarkok helyőrzőit.

import { bench } from 'vitest';

bench.todo('unimplemented test');

describe

Ha a test vagy bench függvényeket egy fájl legfelső szintjén használod, azok a fájl implicit tesztcsomagjába tartoznak. A describe használatával új tesztcsomagot definiálhatsz az aktuális kontextusban. Ez egy kapcsolódó tesztekből, benchmarkokból és más beágyazott tesztcsomagokból álló halmaz. A tesztcsomagokkal rendszerezheted a teszteket és benchmarkokat, ezáltal átláthatóbbá téve az eredményeket.

// basic.spec.ts
// tesztek rendszerezése

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

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

describe('person', () => {
  test('a személy definiált', () => {
    expect(person).toBeDefined();
  });

  test('aktív', () => {
    expect(person.isActive).toBeTruthy();
  });

  test('életkor korlát', () => {
    expect(person.age).toBeLessThanOrEqual(32);
  });
});

// basic.bench.ts
// benchmarkok rendszerezése

import { bench, describe } from 'vitest';

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

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

A describe blokkokat egymásba is ágyazhatod, ha a tesztek vagy benchmarkok hierarchikus felépítésűek:

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

function numberToCurrency(value) {
  if (typeof value !== 'number') throw new Error('Value must be a number');

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

describe('numberToCurrency', () => {
  describe('érvénytelen szám esetén', () => {
    test('nem szám típusú érték hibát ad', () => {
      expect(() => numberToCurrency('abc')).toThrowError();
    });
  });

  describe('érvényes szám esetén', () => {
    test('helyes pénznemformátumot ad vissza', () => {
      expect(numberToCurrency(10000)).toBe('10,000.00');
    });
  });
});

describe.skip

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

A describe.skip használatával kihagyhatsz egy adott describe blokkot.

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

describe.skip('kihagyott tesztcsomag', () => {
  test('négyzetgyök', () => {
    // A tesztcsomag kihagyásra került, nincs hiba
    assert.equal(Math.sqrt(4), 3);
  });
});

describe.skipIf

Típus: (condition: any) => void
Bizonyos esetekben a tesztcsomagokat többször is futtathatod különböző környezetekben. Néhány tesztcsomag környezetfüggő lehet. Ahelyett, hogy a tesztcsomagot if utasítással vennéd körül, használhatod a describe.skipIf függvényt a tesztcsomag kihagyására, ha a feltétel igaz.
ts
```
import { describe, test } from 'vitest';

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

describe.skipIf(isDev)('csak élesben futó teszt', () => {
  // ez a teszt csak éles környezetben fut
});
```

WARNING

Ezt a szintaxist nem használhatod, ha a Vitestet típusellenőrzőként használod.

describe.only

Típus: (name: string | Function, fn: TestFunction, options?: number | TestOptions) => void
A describe.only használatával csak a megjelölt tesztcsomagokat futtathatod.
ts
```
// Csak ez a tesztcsomag (és a többi "only" jelölésű) fut le
describe.only('tesztcsomag', () => {
  test('négyzetgyök', () => {
    assert.equal(Math.sqrt(4), 3);
  });
});

describe('másik tesztcsomag', () => {
  // ... kihagyásra kerül
});
```
Néha hasznos lehet, ha egy adott fájlban csak az only teszteket futtatjuk, figyelmen kívül hagyva a többi tesztet, amelyek zavarják a kimenetet.
Ehhez futtasd a vitest parancsot a kérdéses teszteket tartalmazó fájllal.
```
# vitest interesting.test.ts
```

describe.concurrent

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

A describe.concurrent egy tesztcsomagban minden tesztet párhuzamosnak jelöl meg.

// A tesztcsomagban lévő összes teszt párhuzamosan fut
describe.concurrent('tesztcsomag', () => {
  test('párhuzamos teszt 1', async () => {
    /* ... */
  });
  test('párhuzamos teszt 2', async () => {
    /* ... */
  });
  test.concurrent('párhuzamos teszt 3', async () => {
    /* ... */
  });
});

A .skip, .only és .todo érvényes a párhuzamos tesztcsomagokra. Az alábbi kombinációk mind érvényesek:

describe.concurrent(/* ... */);
describe.skip.concurrent(/* ... */); // vagy describe.concurrent.skip(/* ... */)
describe.only.concurrent(/* ... */); // vagy describe.concurrent.only(/* ... */)
describe.todo.concurrent(/* ... */); // vagy describe.concurrent.todo(/* ... */)

Konkurens tesztek futtatásakor a pillanatképeknek (Snapshots) és az állításoknak (Assertions) a helyi Teszt Konteksztusból kell használniuk az expect függvényt, hogy a megfelelő teszt kerüljön felismerésre.

describe.concurrent('tesztcsomag', () => {
  test('párhuzamos teszt 1', async ({ expect }) => {
    expect(foo).toMatchSnapshot();
  });
  test('párhuzamos teszt 2', async ({ expect }) => {
    expect(foo).toMatchSnapshot();
  });
});

WARNING

Ezt a szintaxist nem használhatod, ha a Vitestet típusellenőrzőként használod.

describe.sequential

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

A describe.sequential egy tesztcsomagban minden tesztet szekvenciálisnak jelöl meg. Ez akkor hasznos, ha a teszteket szekvenciálisan szeretnéd futtatni a describe.concurrent blokkon belül, vagy a --sequence.concurrent parancssori opcióval.

describe.concurrent('tesztcsomag', () => {
  test('párhuzamos teszt 1', async () => {
    /* ... */
  });
  test('párhuzamos teszt 2', async () => {
    /* ... */
  });

  describe.sequential('', () => {
    test('szekvenciális teszt 1', async () => {
      /* ... */
    });
    test('szekvenciális teszt 2', async () => {
      /* ... */
    });
  });
});

describe.shuffle

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

A Vitest lehetővé teszi az összes teszt véletlenszerű sorrendben történő futtatását a --sequence.shuffle CLI flag-en vagy a sequence.shuffle konfigurációs opción keresztül, de ha a tesztcsomagodnak csak egy részét szeretnéd véletlenszerű sorrendben futtatni, akkor megjelölheted ezzel a flag-gel.

describe.shuffle('tesztcsomag', () => {
  test('véletlen sorrendű teszt 1', async () => {
    /* ... */
  });
  test('véletlen sorrendű teszt 2', async () => {
    /* ... */
  });
  test('véletlen sorrendű teszt 3', async () => {
    /* ... */
  });
});
// a sorrend a sequence.seed konfigurációs opciótól függ (alapértelmezett értéke: Date.now())

A .skip, .only és .todo működik a véletlenszerű tesztcsomagokkal.

WARNING

Ezt a szintaxist nem használhatod, ha a Vitestet típusellenőrzőként használod.

describe.todo

Típus: (name: string | Function) => void
A describe.todo használatával csonkokat (stub) hozhatsz létre a később megvalósítandó tesztcsomagokhoz. A tesztekhez bejegyzés jelenik meg a jelentésben, így tudod, hogy még hány tesztet kell megvalósítanod.
ts
```
// Ehhez a tesztcsomaghoz bejegyzés jelenik meg a jelentésben
describe.todo('nem implementált tesztcsomag');
```

describe.each

Típus: (cases: ReadonlyArray<T>, ...args: any[]): (name: string | Function, fn: (...args: T[]) => void, options?: number | TestOptions) => void

A describe.each akkor használd, ha több teszt is ugyanazoktól az adatoktól függ.

describe.each([
  { a: 1, b: 1, expected: 2 },
  { a: 1, b: 2, expected: 3 },
  { a: 2, b: 1, expected: 3 },
])('objektum összeadása ($a, $b)', ({ a, b, expected }) => {
  test(`visszaadja: ${expected}`, () => {
    expect(a + b).toBe(expected);
  });

  test(`a visszaadott érték nem lehet nagyobb, mint ${expected}`, () => {
    expect(a + b).not.toBeGreaterThan(expected);
  });

  test(`a visszaadott érték nem lehet kisebb, mint ${expected}`, () => {
    expect(a + b).not.toBeLessThan(expected);
  });
});

A Vitest 0.25.3-tól kezdve sablon string táblázatot is használhatsz.

Az első sornak oszlopneveket kell tartalmaznia, | karakterrel elválasztva;
Egy vagy több további adatsor sablon literál kifejezésként megadva a ${value} szintaxissal.

describe.each`
  a             | b      | expected
  ${1}          | ${1}   | ${2}
  ${'a'}        | ${'b'} | ${'ab'}
  ${[]}         | ${'b'} | ${'b'}
  ${{}}         | ${'b'} | ${'[object Object]b'}
  ${{ asd: 1 }} | ${'b'} | ${'[object Object]b'}
`('sablon string összeadása ($a, $b)', ({ a, b, expected }) => {
  test(`visszaadja: ${expected}`, () => {
    expect(a + b).toBe(expected);
  });
});

WARNING

Ezt a szintaxist nem használhatod, ha a Vitestet típusellenőrzőként használod.

Felkészülés és takarítás

Ezek a függvények lehetővé teszik, hogy bekapcsolódj a tesztek életciklusába, így elkerülheted a beállítási és lebontási kód ismétlését. Az aktuális kontextusra vonatkoznak: a fájlra, ha a legfelső szinten használják őket, vagy az aktuális tesztcsomagra, ha egy describe blokkon belül vannak. Ezek a hook-ok nem kerülnek meghívásra, ha a Vitestet típusellenőrzőként futtatod.

beforeEach

Típus: beforeEach(fn: () => Awaitable<void>, timeout?: number)
Regisztrál egy visszahívást, amelyet az aktuális kontextusban lévő tesztek előtt kell végrehajtani. Ha a függvény egy promise-t ad vissza, a Vitest megvárja, amíg a promise feloldódik, mielőtt futtatná a tesztet.
Opcionálisan megadhatsz egy időkorlátot (ezredmásodpercben), amely meghatározza, hogy mennyi ideig kell várni a leállítás előtt. Az alapértelmezett érték 5 másodperc.
ts
```
import { beforeEach } from 'vitest';

beforeEach(async () => {
  // Törli a mock-okat, és hozzáad néhány tesztadatot minden tesztfuttatás előtt
  await stopMocking();
  await addUser({ name: 'John' });
});
```
Itt a beforeEach biztosítja, hogy a felhasználó minden teszthez hozzá legyen adva.
A Vitest v0.10.0 óta a beforeEach egy opcionális cleanup függvényt is elfogad (ami az afterEach-nek felel meg).
ts
```
import { beforeEach } from 'vitest';

beforeEach(async () => {
  // egyszer fut le minden tesztfuttatás előtt
  await prepareSomething();

  // eltakarító függvény, egyszer fut le minden tesztfuttatás után
  return async () => {
    await resetSomething();
  };
});
```

afterEach

Típus: afterEach(fn: () => Awaitable<void>, timeout?: number)
Regisztrál egy visszahívást, amelyet az aktuális kontextusban lévő tesztek mindegyike után meg kell hívni. Ha a függvény egy promise-t ad vissza, a Vitest megvárja, amíg a promise feloldódik, mielőtt folytatná.
Opcionálisan megadhatsz egy időkorlátot (ezredmásodpercben), amely meghatározza, hogy mennyi ideig kell várni a leállítás előtt. Az alapértelmezett érték 5 másodperc.
ts
```
import { afterEach } from 'vitest';

afterEach(async () => {
  await clearTestingData(); // tesztadatok törlése minden tesztfuttatás után
});
```
Itt az afterEach biztosítja, hogy a tesztadatok minden teszt után törlődjenek.

beforeAll

Típus: beforeAll(fn: () => Awaitable<void>, timeout?: number)
Regisztrál egy visszahívást, amelyet egyszer meg kell hívni az összes teszt futtatásának megkezdése előtt az aktuális kontextusban. Ha a függvény egy promise-t ad vissza, a Vitest megvárja, amíg a promise feloldódik, mielőtt futtatná a teszteket.
Opcionálisan megadhatsz egy időkorlátot (ezredmásodpercben), amely meghatározza, hogy mennyi ideig kell várni a leállítás előtt. Az alapértelmezett érték 5 másodperc.
ts
```
import { beforeAll } from 'vitest';

beforeAll(async () => {
  await startMocking(); // egyszer fut le az összes teszt futtatása előtt
});
```
Itt a beforeAll biztosítja, hogy a mock adatok be legyenek állítva a tesztek futtatása előtt.
A Vitest v0.10.0 óta a beforeAll egy opcionális cleanup függvényt is elfogad (ami az afterAll-nak felel meg).
ts
```
import { beforeAll } from 'vitest';

beforeAll(async () => {
  // egyszer fut le az összes teszt futtatása előtt
  await startMocking();

  // eltakarító függvény, egyszer fut le az összes teszt futtatása után
  return async () => {
    await stopMocking();
  };
});
```

afterAll

Típus: afterAll(fn: () => Awaitable<void>, timeout?: number)
Regisztrál egy visszahívást, amelyet egyszer meg kell hívni az összes teszt lefutása után az aktuális kontextusban. Ha a függvény egy promise-t ad vissza, a Vitest megvárja, amíg a promise feloldódik, mielőtt folytatná.
Opcionálisan megadhatsz egy időkorlátot (ezredmásodpercben), amely meghatározza, hogy mennyi ideig kell várni a leállítás előtt. Az alapértelmezett érték 5 másodperc.
ts
```
import { afterAll } from 'vitest';

afterAll(async () => {
  await stopMocking(); // ez a metódus az összes teszt lefutása után fut le
});
```
Itt az afterAll biztosítja, hogy a stopMocking metódus az összes teszt lefutása után meghívásra kerüljön.

Teszt API Dokumentáció ​

test ​

test.extend ​

test.skip ​

test.skipIf ​

test.runIf ​

test.only ​

test.concurrent ​

test.todo ​

test.fails ​

test.each ​

bench ​

bench.skip ​

bench.only ​

bench.todo ​

describe ​

describe.skip ​

describe.skipIf ​

describe.only ​

describe.concurrent ​

describe.sequential ​

describe.shuffle ​

describe.todo ​

describe.each ​

Felkészülés és takarítás ​

beforeEach ​

afterEach ​

beforeAll ​

afterAll ​

Teszt API Dokumentáció

test

test.extend

test.skip

test.skipIf

test.runIf

test.only

test.concurrent

test.todo

test.fails

test.each

bench

bench.skip

bench.only

bench.todo

describe

describe.skip

describe.skipIf

describe.only

describe.concurrent

describe.sequential

describe.shuffle

describe.todo

describe.each

Felkészülés és takarítás

beforeEach

afterEach

beforeAll

afterAll