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

Vitest 1.3.0 zastaral použití možností jako posledního parametru. Do verze 2.0.0, kdy bude tato syntaxe odstraněna, se bude zobrazovat zpráva o zastarání. Pokud potřebujete předat možnosti, použijte druhý argument funkce test.

import { test } from 'vitest';

test('flaky test', () => {}, { retry: 3 }); 
test('flaky test', { retry: 3 }, () => {});

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.

Od verze Vitest 1.3.0 podporuje většina možností jak tečkovou syntaxi, tak syntaxi objektu, což vám umožňuje používat styl, který preferujete.

dot-syntaxobject-syntax 1.3.0+

import { test } from 'vitest';

test.skip('skipped test', () => {
  // some logic that fails right now
});

import { test } from 'vitest';

test('skipped test', { skip: true }, () => {
  // some logic that fails right now
});

test

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.

import { expect, test } from 'vitest';

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

test.extend 0.32.3+

Alias: it.extend

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

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

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.

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

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

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.

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

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.sequential

Alias: it.sequential

test.sequential označí test jako sekvenční. To je užitečné, pokud chcete spouštět testy postupně uvnitř describe.concurrent nebo s volbou příkazového řádku --sequence.concurrent.

import { describe, test } from 'vitest';

// ---cut---
// s možností konfigurace { sequence: { concurrent: true } }
test('concurrent test 1', async () => {
  /* ... */
});
test('concurrent test 2', async () => {
  /* ... */
});

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

// uvnitř souběžného balíku
describe.concurrent('suite', () => {
  test('concurrent test 1', async () => {
    /* ... */
  });
  test('concurrent test 2', async () => {
    /* ... */
  });

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

test.todo

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.

// An entry will be shown in the report for this test
test.todo('unimplemented test');

test.fails

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

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 ('%')

import { expect, test } from 'vitest';

// ---cut---
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}.

import { expect, test } from 'vitest';

// ---cut---
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: number | string) {
  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

Alias: suite.skip

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

Alias: suite.skipIf

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).

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.runIf

Alias: suite.runIf

Opak describe.skipIf.

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

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

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

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.

import { assert, describe, test } from 'vitest';
// ---cut---
// 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

Alias: suite.concurrent

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

import { describe, test } from 'vitest';
// ---cut---
// 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

Alias: suite.sequential

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.

import { describe, test } from 'vitest';
// ---cut---
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

Alias: suite.shuffle

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.

import { describe, test } from 'vitest';
// ---cut---
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

Alias: suite.todo

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.

// Ve zprávě se zobrazí položka pro tuto sadu
describe.todo('unimplemented suite');

describe.each

Alias: suite.each

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

import { describe, expect, test } from 'vitest';
// ---cut---
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}.

import { describe, expect, test } from 'vitest';
// ---cut---
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í (Setup and Teardown)

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.

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).

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.

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.

TIP

Vitest 1.3.0 přidal hook onTestFinished. Můžete jej zavolat během provádění testu, abyste vyčistili jakýkoli stav po dokončení 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.

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).

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.

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ů.

Testovací háčky

Vitest poskytuje několik háčků, které můžete volat během provádění testu, abyste vyčistili stav po dokončení testu.

WARNING

Tyto háčky vyvolají chybu, pokud jsou volány mimo tělo testu.

onTestFinished 1.3.0+

Tento háček je vždy volán po dokončení provádění testu. Je volán po háčcích afterEach, protože mohou ovlivnit výsledek testu. Obdrží objekt TaskResult s aktuálním výsledkem testu.

import { onTestFinished, test } from 'vitest';

test('performs a query', () => {
  const db = connectDb();
  onTestFinished(() => db.close());
  db.query('SELECT * FROM users');
});

WARNING

Pokud spouštíte testy souběžně, měli byste vždy používat háček onTestFinished z kontextu testu, protože Vitest nesleduje souběžné testy v globálních háčcích:

import { test } from 'vitest';

test.concurrent('performs a query', ({ onTestFinished }) => {
  const db = connectDb();
  onTestFinished(() => db.close());
  db.query('SELECT * FROM users');
});

Tento háček je zvláště užitečný při vytváření opakovaně použitelné logiky:

// Toto může být v samostatném souboru
function getTestDb() {
  const db = connectMockedDb();
  onTestFinished(() => db.close());
  return db;
}

test('performs a user query', async () => {
  const db = getTestDb();
  expect(await db.query('SELECT * from users').perform()).toEqual([]);
});

test('performs an organization query', async () => {
  const db = getTestDb();
  expect(await db.query('SELECT * from organizations').perform()).toEqual([]);
});

TIP

Tento háček je vždy volán v opačném pořadí a není ovlivněn možností sequence.hooks.

onTestFailed

Tento háček je volán pouze po selhání testu. Je volán po háčcích afterEach, protože mohou ovlivnit výsledek testu. Obdrží objekt TaskResult s aktuálním výsledkem testu. Tento háček je užitečný pro ladění.

import { onTestFailed, test } from 'vitest';

test('performs a query', () => {
  const db = connectDb();
  onTestFailed(e => {
    console.log(e.result.errors);
  });
  db.query('SELECT * FROM users');
});

WARNING

Pokud spouštíte testy souběžně, měli byste vždy používat háček onTestFailed z kontextu testu, protože Vitest nesleduje souběžné testy v globálních háčcích:

import { test } from 'vitest';

test.concurrent('performs a query', ({ onTestFailed }) => {
  const db = connectDb();
  onTestFailed(result => {
    console.log(result.errors);
  });
  db.query('SELECT * FROM users');
});

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

test ​

test.extend 0.32.3+ ​

test.skip ​

test.skipIf ​

test.runIf ​

test.only ​

test.concurrent ​

test.sequential ​

test.todo ​

test.fails ​

test.each ​

bench ​

bench.skip ​

bench.only ​

bench.todo ​

describe ​

describe.skip ​

describe.skipIf ​

describe.runIf ​

describe.only ​

describe.concurrent ​

describe.sequential ​

describe.shuffle ​

describe.todo ​

describe.each ​

Nastavení a ukončení (Setup and Teardown) ​

beforeEach ​

afterEach ​

beforeAll ​

afterAll ​

Testovací háčky ​

onTestFinished 1.3.0+ ​

onTestFailed ​

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

test

test.extend 0.32.3+

test.skip

test.skipIf

test.runIf

test.only

test.concurrent

test.sequential

test.todo

test.fails

test.each

bench

bench.skip

bench.only

bench.todo

describe

describe.skip

describe.skipIf

describe.runIf

describe.only

describe.concurrent

describe.sequential

describe.shuffle

describe.todo

describe.each

Nastavení a ukončení (Setup and Teardown)

beforeEach

afterEach

beforeAll

afterAll

Testovací háčky

onTestFinished 1.3.0+

onTestFailed