Referenční příručka k Test API

Následující typy se používají v typových podpisech níže

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

interface TestOptions {
  /**
   * Test selže, pokud jeho provedení trvá příliš dlouho.
   */
  timeout?: number;
  /**
   * Pokud test selže, provede se tolikrát, kolikrát je uvedeno.
   *
   * @default 0
   */
  retry?: number;
  /**
   * Stejný test se opakuje několikrát, i když opakovaně selže.
   * Pokud máte možnost "retry" a test selže, použije každé opakování v každém cyklu.
   * Užitečné pro odhalování náhodných selhání.
   *
   * @default 0
   */
  repeats?: number;
}

Když testovací funkce vrací promise (objekt pro asynchronní operace), spouštěč testů počká, dokud se promise nevyřeší, aby shromáždil asynchronní očekávání. Pokud je promise odmítnut, test selže.

TIP

V Jest může být TestFunction také typu (done: DoneCallback) => void. Pokud je tento způsob použit, test nebude ukončen, dokud nebude zavolána funkce done. Stejného výsledku můžete dosáhnout pomocí funkce async, viz Průvodce migrací, sekce Done Callback.

test

Typ: (name: string | Function, fn: TestFunction, timeout?: number | TestOptions) => void
Alias: it
test definuje sadu souvisejících očekávání. Přijímá název testu a funkci, která obsahuje očekávání, která se mají ověřit.
Můžete volitelně zadat timeout (v milisekundách), abyste určili, jak dlouho čekat před ukončením testu. Výchozí hodnota je 5 sekund a lze ji globálně nastavit pomocí testTimeout.
ts
```
import { expect, test } from 'vitest';

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

test.extend

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

Verze: Vitest 0.32.3

Pomocí test.extend můžete rozšířit testovací kontext o vlastní přípravky (fixtures). Tím se vrátí nový test, který je také rozšiřitelný, takže můžete skládat další přípravky nebo přepsat stávající rozšířením podle potřeby. Další informace naleznete v Rozšíření testovacího kontextu.

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

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

Alias: it.skip

Pokud chcete přeskočit provádění některých testů, ale nechcete smazat jejich kód, použijte test.skip.

import { assert, test } from 'vitest';

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

Test můžete také přeskočit dynamicky voláním skip na jeho kontextu:

import { assert, test } from 'vitest';

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

test.skipIf

Typ: (condition: any) => Test
Alias: it.skipIf
V některých případech se testy spouští opakovaně v různých prostředích, přičemž některé testy jsou specifické pro dané prostředí. Místo použití if pro obalení testovacího kódu můžete použít test.skipIf pro přeskočení testu, pokud je daná podmínka splněna.
ts
```
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

Tuto syntaxi nemůžete použít, pokud používáte Vitest jako kontrolu typů.

test.runIf

Typ: (condition: any) => Test

Alias: it.runIf

Opak test.skipIf.

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

Tuto syntaxi nemůžete použít, pokud používáte Vitest jako kontrolu typů.

test.only

Typ: (name: string | Function, fn: TestFunction, timeout?: number) => void
Alias: it.only
Použijte test.only, abyste spustili pouze určité testy v dané sadě. To je užitečné při ladění.
Můžete volitelně zadat timeout (v milisekundách), abyste určili, jak dlouho čekat před ukončením testu. Výchozí hodnota je 5 sekund a lze ji globálně nastavit pomocí testTimeout.
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ěkdy je velmi užitečné spouštět testy označené only v určitém souboru a ignorovat všechny ostatní testy z celé testovací sady, které znečišťují výstup.
Chcete-li to provést, spusťte vitest se specifickým souborem obsahujícím dotyčné testy.
```
# vitest interesting.test.ts
```

test.concurrent

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

Alias: it.concurrent

test.concurrent označuje testy, které se mají spouštět paralelně. Přijímá název testu, asynchronní funkci s testy a volitelný timeout (v milisekundách).

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 () => {
    /* ... */
  });
});

test.skip, test.only a test.todo fungují s concurrent testy. Všechny následující kombinace jsou platné:

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

Při provádění paralelních testů musí snímky (snapshots) a tvrzení (assertions) používat expect z místního Test Context, aby bylo zajištěno, že je detekován správný test.

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

WARNING

Tuto syntaxi nemůžete použít, pokud používáte Vitest jako kontrolu typů.

test.todo

Typ: (name: string | Function) => void
Alias: it.todo
Použijte test.todo k vytvoření zástupných testů, které budou implementovány později. V sestavě se zobrazí záznam pro tyto testy, abyste věděli, kolik testů ještě musíte implementovat.
ts
```
// An entry will be shown in the report for this test
test.todo('unimplemented test');
```

test.fails

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

Alias: it.fails

Pomocí test.fails označíte, že dané tvrzení má selhat.

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

Tuto syntaxi nemůžete použít, pokud používáte Vitest jako kontrolu typů.

test.each

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

Alias: it.each

Použijte test.each, když potřebujete spustit stejný test s různými proměnnými. Parametry můžete vložit pomocí printf formatting v názvu testu v pořadí parametrů testovací funkce.

%s: string
%d: number
%i: integer
%f: floating point value
%j: json
%o: object
%#: index of the test case
%%: single percent sign ('%')

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

Můžete také přistupovat k vlastnostem objektu pomocí předpony $, pokud používáte objekty jako argumenty:

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

Můžete také přistupovat k atributům objektu pomocí ., pokud používáte objekty jako argumenty:

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

Počínaje Vitest 0.25.3 můžete také použít tabulku šablonových řetězců.

První řádek by měl obsahovat názvy sloupců oddělené znakem |;
Jeden nebo více následujících řádků dat zadaných jako template literal expressions pomocí syntaxe ${value}.

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

Pokud chcete mít přístup k TestContext, použijte describe.each s jedním testem.

TIP

Vitest zpracovává $values pomocí metody format knihovny Chai. Pokud je hodnota příliš zkrácena, můžete zvýšit chaiConfig.truncateThreshold v konfiguračním souboru.

WARNING

Tuto syntaxi nemůžete použít, pokud používáte Vitest jako kontrolu typů.

bench

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

bench definuje benchmark. V kontextu Vitest je benchmark funkce definující sérii operací. Vitest tuto funkci spouští opakovaně, aby zobrazil různé výsledky výkonu.

Vitest interně využívá knihovnu tinybench a přebírá všechny její možnosti, které lze použít jako třetí argument.

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 {
  /**
   * Čas potřebný pro spuštění benchmark úlohy (milisekundy).
   * @default 500
   */
  time?: number;

  /**
   * Počet opakování, kolikrát by se měla úloha spustit, i když je časová možnost dokončena.
   * @default 10
   */
  iterations?: number;

  /**
   * Funkce pro získání aktuálního timestamp v milisekundách.
   */
  now?: () => number;

  /**
   * An AbortSignal for aborting the benchmark
   */
  signal?: AbortSignal;

  /**
   * Warmup time (milisekundy).
   * @default 100ms
   */
  warmupTime?: number;

  /**
   * Warmup iterations.
   * @default 5
   */
  warmupIterations?: number;

  /**
   * Setup hook funkce, která se spustí před každou benchmark úlohou (cyklem).
   */
  setup?: Hook;

  /**
   * Teardown hook funkce, která se spustí po každé benchmark úloze (cyklu).
   */
  teardown?: Hook;
}

bench.skip

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

Pro přeskočení spouštění určitých benchmarků můžete použít syntaxi bench.skip.

import { bench } from 'vitest';

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

bench.only

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

Pomocí bench.only spustíte pouze vybrané benchmarky v dané sadě. To je užitečné při ladění.

import { bench } from 'vitest';

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

bench.todo

Typ: (name: string | Function) => void

Pomocí bench.todo vytvoříte stubs (zástupné benchmarky) pro pozdější implementaci.

import { bench } from 'vitest';

bench.todo('unimplemented test');

describe

Pokud použijete test nebo bench na nejvyšší úrovni souboru, jsou tyto funkce zahrnuty jako součást implicitní sady testů. Pomocí describe můžete definovat novou sadu v aktuálním kontextu, například sadu souvisejících testů, benchmarků nebo dalších vnořených sad. Sada umožňuje uspořádat testy a benchmarky, čímž jsou výstupy přehlednější.

// basic.spec.ts
// organizace testů

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

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

describe('person', () => {
  test('person is defined', () => {
    expect(person).toBeDefined();
  });

  test('is active', () => {
    expect(person.isActive).toBeTruthy();
  });

  test('age limit', () => {
    expect(person.age).toBeLessThanOrEqual(32);
  });
});

// basic.bench.ts
// organizace benchmarků

import { bench, describe } from 'vitest';

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

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

Můžete také vnořovat bloky describe, pokud máte hierarchickou strukturu testů nebo benchmarků:

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('pokud je zadáno neplatné číslo', () => {
    test('pokud obsahuje nečíselné hodnoty, vyhodí chybu', () => {
      expect(() => numberToCurrency('abc')).toThrowError();
    });
  });

  describe('pokud je zadáno platné číslo', () => {
    test('vrací správný formát měny', () => {
      expect(numberToCurrency(10000)).toBe('10,000.00');
    });
  });
});

describe.skip

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

Použijte describe.skip pro přeskočení konkrétního bloku describe.

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

describe.skip('skipped suite', () => {
  test('sqrt', () => {
    // Sada je přeskočena, žádná chyba
    assert.equal(Math.sqrt(4), 3);
  });
});

describe.skipIf

Typ: (condition: any) => void
V některých případech může být potřeba spouštět testovací sady v různých prostředích a některé sady mohou být specifické pro dané prostředí. Místo použití if pro obalení sady můžete použít describe.skipIf k jejímu přeskočení, pokud je daná podmínka splněna (truthy).
ts
```
import { describe, test } from 'vitest';

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

describe.skipIf(isDev)('prod only test', () => {
  // tento test se spouští pouze v produkci
});
```

WARNING

Tuto syntaxi nemůžete použít, pokud používáte Vitest jako kontrolu typů.

describe.only

Typ: (name: string | Function, fn: TestFunction, options?: number | TestOptions) => void
Použijte describe.only ke spuštění pouze určitých sad.
ts
```
// Spustí se pouze tato sada (a další označené jako only)
describe.only('suite', () => {
  test('sqrt', () => {
    assert.equal(Math.sqrt(4), 3);
  });
});

describe('other suite', () => {
  // ... bude přeskočeno
});
```
Někdy je velmi užitečné spouštět testy only v určitém souboru a ignorovat všechny ostatní testy, které znečišťují výstup.
Chcete-li to provést, spusťte vitest s konkrétním souborem obsahujícím příslušné testy.
```
# vitest interesting.test.ts
```

describe.concurrent

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

describe.concurrent označuje všechny testy v sadě jako souběžné (paralelní).

// Všechny testy v této sadě budou spuštěny paralelně
describe.concurrent('suite', () => {
  test('concurrent test 1', async () => {
    /* ... */
  });
  test('concurrent test 2', async () => {
    /* ... */
  });
  test.concurrent('concurrent test 3', async () => {
    /* ... */
  });
});

.skip, .only a .todo fungují se souběžnými sadami. Všechny následující kombinace jsou platné:

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

Při spouštění souběžných testů musí snímky (Snapshots) a tvrzení (Assertions) používat expect z lokálního Testovacího kontextu, aby bylo zajištěno, že je detekován správný test.

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

WARNING

Tuto syntaxi nemůžete použít, pokud používáte Vitest jako kontrolu typů.

describe.sequential

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

describe.sequential označí všechny testy v sadě jako sekvenční. To je užitečné, pokud potřebujete spouštět testy sekvenčně uvnitř bloku describe.concurrent nebo s použitím volby --sequence.concurrent v příkazovém řádku.

describe.concurrent('suite', () => {
  test('concurrent test 1', async () => {
    /* ... */
  });
  test('concurrent test 2', async () => {
    /* ... */
  });

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

describe.shuffle

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

Vitest umožňuje spouštět testy v náhodném pořadí pomocí příznaku CLI --sequence.shuffle nebo volby konfigurace sequence.shuffle. Pokud chcete v náhodném pořadí spouštět pouze část testovací sady, můžete ji označit tímto příznakem.

describe.shuffle('suite', () => {
  test('random test 1', async () => {
    /* ... */
  });
  test('random test 2', async () => {
    /* ... */
  });
  test('random test 3', async () => {
    /* ... */
  });
});
// pořadí závisí na možnosti sequence.seed v konfiguraci (ve výchozím nastavení Date.now())

.skip, .only a .todo fungují s náhodnými sadami.

WARNING

Tuto syntaxi nemůžete použít, pokud používáte Vitest jako kontrolu typů.

describe.todo

Typ: (name: string | Function) => void
Použijte describe.todo k označení sad, které budou implementovány později, jako zástupné symboly (stuby). Ve zprávě se zobrazí položka pro testy, abyste věděli, kolik testů ještě musíte implementovat.
ts
```
// Ve zprávě se zobrazí položka pro tuto sadu
describe.todo('unimplemented suite');
```

describe.each

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

Použijte describe.each, pokud máte více než jeden test, který závisí na stejných datech.

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

  test(`returned value not be greater than ${expected}`, () => {
    expect(a + b).not.toBeGreaterThan(expected);
  });

  test(`returned value not be less than ${expected}`, () => {
    expect(a + b).not.toBeLessThan(expected);
  });
});

Počínaje Vitest 0.25.3 můžete také použít tabulku vytvořenou pomocí template literals.

První řádek by měl obsahovat názvy sloupců oddělené znakem |;
Jeden nebo více následujících řádků dat zadaných jako výrazy šablonových literálů pomocí syntaxe ${value}.

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

WARNING

Tuto syntaxi nemůžete použít, pokud používáte Vitest jako kontrolu typů.

Nastavení a ukončení

Tyto funkce umožňují zasáhnout do životního cyklu testů a vyhnout se tak opakování kódu pro nastavení a ukončení. Platí pro aktuální kontext. Pokud jsou použity na nejvyšší úrovni, vztahují se na celý soubor. Pokud jsou uvnitř bloku describe, platí pouze pro danou sadu. Tyto pomocné funkce nejsou volány, pokud spouštíte Vitest jako kontrolu typů.

beforeEach

Typ: beforeEach(fn: () => Awaitable<void>, timeout?: number)
Zaregistruje funkci, která se má spustit před každým testem v aktuálním kontextu. Pokud funkce vrací promise, Vitest čeká, dokud se promise nevyřeší, než spustí test.
Volitelně můžete předat timeout (v milisekundách) definující, jak dlouho čekat před ukončením. Výchozí hodnota je 5 sekund.
ts
```
import { beforeEach } from 'vitest';

beforeEach(async () => {
  // Vymaže imitační data a přidá některá testovací data po spuštění každého testu
  await stopMocking();
  await addUser({ name: 'John' });
});
```
Zde beforeEach zajišťuje, že uživatel je přidán před každým testem.
Od verze Vitest v0.10.0 umožňuje beforeEach také definovat volitelnou úklidovou funkci (ekvivalentní afterEach).
ts
```
import { beforeEach } from 'vitest';

beforeEach(async () => {
  // voláno jednou před spuštěním každého testu
  await prepareSomething();

  // funkce pro úklid, volána jednou po spuštění každého testu
  return async () => {
    await resetSomething();
  };
});
```

afterEach

Typ: afterEach(fn: () => Awaitable<void>, timeout?: number)
Zaregistruje funkci, která se má spustit po každém testu v aktuálním kontextu. Pokud funkce vrací promise, Vitest čeká, dokud se promise nevyřeší, než bude pokračovat.
Volitelně můžete zadat timeout (v milisekundách) pro určení, jak dlouho čekat před ukončením. Výchozí hodnota je 5 sekund.
ts
```
import { afterEach } from 'vitest';

afterEach(async () => {
  await clearTestingData(); // vymaže testovací data po spuštění každého testu
});
```
Zde afterEach zajišťuje, že testovací data jsou vymazána po každém testu.

beforeAll

Typ: beforeAll(fn: () => Awaitable<void>, timeout?: number)
Zaregistruje funkci, která se má spustit jednou před spuštěním všech testů v aktuálním kontextu. Pokud funkce vrací promise, Vitest čeká, dokud se promise nevyřeší, než spustí testy.
Volitelně můžete zadat timeout (v milisekundách) pro určení, jak dlouho čekat před ukončením. Výchozí hodnota je 5 sekund.
ts
```
import { beforeAll } from 'vitest';

beforeAll(async () => {
  await startMocking(); // voláno jednou před spuštěním všech testů
});
```
Zde beforeAll zajišťuje, že jsou imitační data nastavena před spuštěním testů.
Od verze Vitest v0.10.0 umožňuje beforeAll také definovat volitelnou úklidovou funkci (ekvivalentní afterAll).
ts
```
import { beforeAll } from 'vitest';

beforeAll(async () => {
  // voláno jednou před spuštěním všech testů
  await startMocking();

  // funkce pro úklid, volána jednou po spuštění všech testů
  return async () => {
    await stopMocking();
  };
});
```

afterAll

Typ: afterAll(fn: () => Awaitable<void>, timeout?: number)
Zaregistruje funkci, která se má spustit jednou po spuštění všech testů v aktuálním kontextu. Pokud funkce vrací promise, Vitest čeká, dokud se promise nevyřeší, než bude pokračovat.
Volitelně můžete zadat timeout (v milisekundách) pro určení, jak dlouho čekat před ukončením. Výchozí hodnota je 5 sekund.
ts
```
import { afterAll } from 'vitest';

afterAll(async () => {
  await stopMocking(); // tato metoda je volána po spuštění všech testů
});
```
Zde afterAll zajišťuje, že metoda stopMocking je volána po spuštění všech testů.

Referenční příručka k Test API ​

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 ​

Nastavení a ukončení ​

beforeEach ​

afterEach ​

beforeAll ​

afterAll ​

Referenční příručka k Test API

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

Nastavení a ukončení

beforeEach

afterEach

beforeAll

afterAll