Testovací reference API

Následující typy se používají v signaturách typů níže.

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

interface TestOptions {
  /**
   * Test selže, pokud trvá příliš dlouho.
   */
  timeout?: number;
  /**
   * Test se zopakuje zadaný početkrát, pokud selže.
   *
   * @default 0
   */
  retry?: number;
  /**
   * Stejný test se zopakuje několikrát, i když pokaždé selže.
   * Pokud je aktivní možnost "retry" a test selže, každý pokus se provede v rámci každého cyklu opakování.
   * Užitečné pro ladění občasných selhání.
   *
   * @default 0
   */
  repeats?: number;
}

Když testovací funkce vrátí Promise, spouštěč počká, dokud se Promise nevyřeší, aby shromáždil asynchronní očekávání. Pokud je Promise odmítnuta, test selže.

TIP

V Jestu může být TestFunction také typu (done: DoneCallback) => void. Pokud je tato forma použita, test nebude dokončen, dokud nebude zavolána done. Toho lze dosáhnout pomocí async funkce, viz sekce Průvodce migrací Done Callback.

Možnosti můžete definovat řetězením metod na funkci:

import { test } from 'vitest';

test.skip('skipped test', () => {
  // nějaká logika, která aktuálně selhává
});

test.concurrent.skip('skipped concurrent test', () => {
  // nějaká logika, která aktuálně selhává
});

Ale můžete také místo toho poskytnout objekt jako druhý argument:

import { test } from 'vitest';

test('skipped test', { skip: true }, () => {
  // nějaká logika, která aktuálně selhává
});

test('skipped concurrent test', { skip: true, concurrent: true }, () => {
  // nějaká logika, která aktuálně selhává
});

Oba způsoby fungují zcela stejně. Použití jednoho z nich je čistě stylistická volba.

Všimněte si, že pokud poskytujete timeout jako poslední argument, již nemůžete použít objekt s možnostmi:

import { test } from 'vitest';

// ✅ toto funguje
test.skip('heavy test', () => {
  // ...
}, 10_000);

// ❌ toto nefunguje
test(
  'heavy test',
  { skip: true },
  () => {
    // ...
  },
  10_000
);

Nicméně, timeout můžete zadat v rámci objektu s možnostmi:

import { test } from 'vitest';

// ✅ toto funguje
test('heavy test', { skip: true, timeout: 10_000 }, () => {
  // ...
});

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í k testování.

Volitelně lze zadat timeout (v milisekundách) pro určení, jak dlouho čekat před ukončením. Výchozí hodnota je 5 sekund a lze ji globálně konfigurovat pomocí testTimeout.

import { expect, test } from 'vitest';

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

test.extend

Alias: it.extend

Použijte test.extend k rozšíření kontextu testu o vlastní fixture. Tím se vrátí nový test, který je navíc rozšiřitelný, takže můžete skládat další fixture nebo přepisovat stávající podle potřeby. Více informací naleznete v Rozšíření kontextu testu.

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 určité testy, ale nechcete smazat kód, můžete použít test.skip k jejich vynechání.

import { assert, test } from 'vitest';

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

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

import { assert, test } from 'vitest';

test('skipped test', context => {
  context.skip();
  // Test přeskočen, žádná chyba
  assert.equal(Math.sqrt(4), 3);
});

Od Vitest 3.1, pokud je podmínka neznámá, můžete ji poskytnout metodě skip jako první argument:

import { assert, test } from 'vitest';

test('skipped test', context => {
  context.skip(Math.random() < 0.5, 'optional message');
  // Test přeskočen, žádná chyba
  assert.equal(Math.sqrt(4), 3);
});

test.skipIf

Alias: it.skipIf

V některých případech můžete spouštět testy vícekrát s různými prostředími a některé z testů mohou být specifické pro dané prostředí. Místo obalování testovacího kódu if můžete použít test.skipIf k přeskočení testu, pokud je podmínka splněna.

import { assert, test } from 'vitest';

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

test.skipIf(isDev)('prod only test', () => {
  // tento test se spouští pouze v produkčním prostředí
});

WARNING

Tuto syntaxi nelze použít, pokud používáte Vitest jako typový kontrolor.

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', () => {
  // tento test se spouští pouze ve vývojovém prostředí
});

WARNING

Tuto syntaxi nelze použít, pokud používáte Vitest jako typový kontrolor.

test.only

Alias: it.only

Použijte test.only ke spuštění pouze určitých testů v dané sadě. To se hodí při ladění.

Volitelně lze zadat timeout (v milisekundách) pro určení, jak dlouho čekat před ukončením. Výchozí hodnota je 5 sekund a lze ji globálně konfigurovat pomocí testTimeout.

import { assert, test } from 'vitest';

test.only('test', () => {
  // Spustí se pouze tento test (a další označené pro exkluzivní spuštění)
  assert.equal(Math.sqrt(4), 2);
});

Někdy je užitečné spustit only testy v určitém souboru a ignorovat ostatní testy, které znečišťují výstup.

K tomu spusťte vitest s konkrétním souborem obsahujícím dotyčné testy.

# vitest interesting.test.ts

test.concurrent

Alias: it.concurrent

test.concurrent označuje po sobě jdoucí testy, které se mají spustit paralelně. Přijímá název testu, asynchronní funkci s testy ke shromáždění a volitelný timeout (v milisekundách).

import { describe, test } from 'vitest';

// Dva testy označené jako souběžné se spustí paralelně
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 paralelními testy. Všechny následující kombinace jsou platné:

test.concurrent(/* ... */);
test.skip.concurrent(/* ... */); // nebo test.concurrent.skip(/* ... */)
test.only.concurrent(/* ... */); // nebo test.concurrent.only(/* ... */)
test.todo.concurrent(/* ... */); // nebo test.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 kontextu testu, aby se zajistilo, ž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 nelze použít, pokud používáte Vitest jako typový kontrolor.

test.sequential

Alias: it.sequential

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

import { describe, test } from 'vitest';

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

// v rámci souběžné sady
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 zástupným testům, které mají být implementovány později. V reportu se zobrazí záznam pro tyto testy, abyste věděli, kolik testů ještě zbývá implementovat.

// V reportu se zobrazí záznam pro tento test
test.todo('unimplemented test');

test.fails

Alias: it.fails

Použijte test.fails k explicitnímu označení, že ověření selže.

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 nelze použít, pokud používáte Vitest jako typový kontrolor.

test.each

Alias: it.each

TIP

Zatímco test.each je poskytován pro kompatibilitu s Jestem, Vitest má také test.for s dodatečnou funkcí pro integraci TestContext.

Použijte test.each, když potřebujete spustit stejný test s různými proměnnými. Parametry můžete vkládat pomocí formátování printf do názvu testu, a to v pořadí, v jakém jsou parametry testovací funkce.

%s: řetězec
%d: číslo
%i: celé číslo
%f: desetinné číslo
%j: json
%o: objekt
%#: index testovacího případu založený na 0
%$: index testovacího případu založený na 1
%%: jeden znak procenta ('%')

import { expect, test } from 'vitest';

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

// výsledek bude
// ✓ add(1, 1) -> 2
// ✓ add(1, 2) -> 3
// ✓ add(2, 1) -> 3

Můžete také přistupovat k vlastnostem objektů a prvkům polí pomocí předpony $:

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

// výsledek bude
// ✓ add(1, 1) -> 2
// ✓ add(1, 2) -> 3
// ✓ add(2, 1) -> 3

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

// výsledek bude
// ✓ add(1, 1) -> 2
// ✓ add(1, 2) -> 3
// ✓ add(2, 1) -> 3

Můžete také přistupovat k vlastnostem 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);
});

// výsledek bude
// ✓ add(1, b) -> 1b
// ✓ add(2, b) -> 2b
// ✓ add(3, b) -> 3b

Od Vitest 0.25.3 můžete také použít tabulku řetězců šablon.

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

import { expect, test } from 'vitest';

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

TIP

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

WARNING

Tuto syntaxi nelze použít, pokud používáte Vitest jako typový kontrolor.

test.for

Alias: it.for

Alternativa k test.each pro poskytnutí TestContext.

Rozdíl od test.each spočívá ve způsobu, jakým jsou pole poskytována v argumentech. Argumenty, které nejsou polem, pro test.for (včetně použití řetězce šablony) fungují přesně stejně jako pro test.each.

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

// `for` nerozbaluje pole (všimněte si hranatých závorek kolem argumentů)
test.for([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('add(%i, %i) -> %i', ([a, b, expected]) => { 
  expect(a + b).toBe(expected);
});

Druhý argument je TestContext a lze jej použít například pro souběžné snímky:

test.concurrent.for([
  [1, 1],
  [1, 2],
  [2, 1],
])('add(%i, %i)', ([a, b], { expect }) => {
  expect(a + b).matchSnapshot();
});

bench

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

bench definuje benchmark. V terminologii Vitestu je benchmark funkce, která definuje sérii operací. Vitest tuto funkci spouští vícekrát, aby zobrazil různé výsledky výkonu.

Vitest interně použí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í benchmarku (v milisekundách)
   * @default 500
   */
  time?: number;

  /**
   * počet opakování úlohy, i po vypršení časového limitu
   * @default 10
   */
  iterations?: number;

  /**
   * funkce pro získání aktuální časové značky v milisekundách
   */
  now?: () => number;

  /**
   * AbortSignal pro zrušení benchmarku
   */
  signal?: AbortSignal;

  /**
   * Vyhodit chybu, pokud úloha selže (události nebudou fungovat, pokud je nastaveno na true)
   */
  throws?: boolean;

  /**
   * doba zahřívání (milisekundy)
   * @default 100ms
   */
  warmupTime?: number;

  /**
   * iterace zahřívání
   * @default 5
   */
  warmupIterations?: number;

  /**
   * funkce nastavení, která se spustí před každým cyklem benchmarku
   */
  setup?: Hook;

  /**
   * funkce pro úklid, která se spustí po každém cyklu benchmarku
   */
  teardown?: Hook;
}

Po spuštění testovacího případu je výstupní struktura informací následující:

  name                      hz     min     max    mean     p75     p99    p995    p999     rme  samples
· normal sorting  6,526,368.12  0.0001  0.3638  0.0002  0.0002  0.0002  0.0002  0.0004  ±1.41%   652638

export interface TaskResult {
  /*
   * poslední chyba, která nastala během spouštění úlohy
   */
  error?: unknown;

  /**
   * Doba v milisekundách potřebná pro spuštění benchmarku (cyklu).
   */
  totalTime: number;

  /**
   * minimální hodnota ve vzorcích
   */
  min: number;
  /**
   * maximální hodnota ve vzorcích
   */
  max: number;

  /**
   * frekvence operací (za sekundu)
   */
  hz: number;

  /**
   * doba trvání každé operace (ms)
   */
  period: number;

  /**
   * vzorky časů každé iterace úlohy (ms)
   */
  samples: number[];

  /**
   * průměr vzorků (odhad průměru populace)
   */
  mean: number;

  /**
   * rozptyl vzorků (odhad rozptylu populace)
   */
  variance: number;

  /**
   * směrodatná odchylka vzorků (odhad směrodatné odchylky populace)
   */
  sd: number;

  /**
   * standardní chyba průměru (tj. směrodatná odchylka výběrového rozdělení výběrového průměru)
   */
  sem: number;

  /**
   * stupně volnosti
   */
  df: number;

  /**
   * kritická hodnota vzorků
   */
  critical: number;

  /**
   * mezní chyba
   */
  moe: number;

  /**
   * relativní mezní chyba
   */
  rme: number;

  /**
   * medián absolutní odchylky
   */
  mad: number;

  /**
   * p50/medián percentil
   */
  p50: number;

  /**
   * p75 percentil
   */
  p75: number;

  /**
   * p99 percentil
   */
  p99: number;

  /**
   * p995 percentil
   */
  p995: number;

  /**
   * p999 percentil
   */
  p999: number;
}

bench.skip

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

Můžete použít syntaxi bench.skip k přeskočení spuštění určitých benchmarků.

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

Použijte bench.only ke spuštění pouze určitých benchmarků v dané sadě. To se hodí 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

Použijte bench.todo k zástupným benchmarkům, které mají být implementovány později.

import { bench } from 'vitest';

bench.todo('unimplemented test');

describe

Když použijete test nebo bench na nejvyšší úrovni souboru, jsou shromážděny jako součást implicitní sady. Pomocí describe můžete definovat novou sadu v aktuálním kontextu, která sdružuje související testy nebo benchmarky a další vnořené sady. Sada vám umožňuje organizovat vaše testy a benchmarky pro jasnější reporty.

// basic.spec.ts
// organizování 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
// organizování 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řit bloky describe, pokud máte hierarchii testů nebo benchmarků:

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

function numberToCurrency(value: number | string) {
  if (typeof value !== 'number') {
    throw new TypeError('Value must be a number');
  }

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

describe('numberToCurrency', () => {
  describe('given an invalid number', () => {
    test('composed of non-numbers to throw error', () => {
      expect(() => numberToCurrency('abc')).toThrowError();
    });
  });

  describe('given a valid number', () => {
    test('returns the correct currency format', () => {
      expect(numberToCurrency(10000)).toBe('10,000.00');
    });
  });
});

describe.skip

Alias: suite.skip

Použijte describe.skip v sadě, abyste vynechali spuštění konkrétního bloku describe.

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

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

describe.skipIf

Alias: suite.skipIf

V některých případech můžete spouštět sady testů vícekrát s různými prostředími a některé sady mohou být specifické pro dané prostředí. Místo obalování sady if můžete použít describe.skipIf k přeskočení sady, pokud je podmínka splněna.

import { describe, test } from 'vitest';

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

describe.skipIf(isDev)('prod only test suite', () => {
  // tato testovací sada se spouští pouze v produkčním prostředí
});

WARNING

Tuto syntaxi nelze použít, pokud používáte Vitest jako typový kontrolor.

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', () => {
  // tato testovací sada se spouští pouze ve vývojovém prostředí
});

WARNING

Tuto syntaxi nelze použít, pokud používáte Vitest jako typový kontrolor.

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

// Spustí se pouze tato sada (a další označené pro exkluzivní spuštění)
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é spustit only testy v určitém souboru, ignorovat všechny ostatní testy z celé testovací sady, které znečišťují výstup.

K tomu spusťte vitest s konkrétním souborem obsahujícím dotyčné testy.

# vitest interesting.test.ts

describe.concurrent

Alias: suite.concurrent

describe.concurrent spouští všechny vnitřní sady a testy paralelně.

import { describe, test } from 'vitest';

// Všechny sady a testy v rámci této sady se spustí paralelně
describe.concurrent('suite', () => {
  test('concurrent test 1', async () => {
    /* ... */
  });
  describe('concurrent suite 2', async () => {
    test('concurrent test inner 1', async () => {
      /* ... */
    });
    test('concurrent test inner 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(/* ... */); // nebo describe.concurrent.skip(/* ... */)
describe.only.concurrent(/* ... */); // nebo describe.concurrent.only(/* ... */)
describe.todo.concurrent(/* ... */); // nebo 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 kontextu testu, aby se zajistilo, ž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 nelze použít, pokud používáte Vitest jako typový kontrolor.

describe.sequential

Alias: suite.sequential

describe.sequential v sadě označuje každý test jako sekvenční. To je užitečné, pokud chcete spouštět testy v sekvenci v rámci describe.concurrent nebo s volbou příkazového řádku --sequence.concurrent.

import { describe, test } from 'vitest';

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 poskytuje způsob, jak spustit všechny testy v náhodném pořadí pomocí příznaku CLI --sequence.shuffle nebo možnosti konfigurace sequence.shuffle, ale pokud chcete, aby se pouze část vaší testovací sady spouštěla v náhodném pořadí, můžete ji označit tímto příznakem.

import { describe, test } from 'vitest';

// nebo describe('suite', { shuffle: true }, ...)
describe.shuffle('suite', () => {
  test('random test 1', async () => {
    /* ... */
  });
  test('random test 2', async () => {
    /* ... */
  });
  test('random test 3', async () => {
    /* ... */
  });

  // `shuffle` se dědí
  describe('still random', () => {
    test('random 4.1', async () => {
      /* ... */
    });
    test('random 4.2', async () => {
      /* ... */
    });
  });

  // zakázat shuffle uvnitř
  describe('not random', { shuffle: false }, () => {
    test('in order 5.1', async () => {
      /* ... */
    });
    test('in order 5.2', async () => {
      /* ... */
    });
  });
});
// pořadí závisí na možnosti sequence.seed v konfiguraci (Date.now() ve výchozím nastavení)

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

WARNING

Tuto syntaxi nelze použít, pokud používáte Vitest jako typový kontrolor.

describe.todo

Alias: suite.todo

Použijte describe.todo k zástupným sadám, které mají být implementovány později. V reportu se zobrazí záznam pro tyto sady, abyste věděli, kolik testů ještě zbývá implementovat.

// V reportu se zobrazí záznam pro tuto sadu
describe.todo('unimplemented suite');

describe.each

Alias: suite.each

TIP

Zatímco describe.each je poskytován pro kompatibilitu s Jestem, Vitest má také describe.for, který zjednodušuje typy argumentů a je v souladu s test.for.

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

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

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

Od Vitest 0.25.3 můžete také použít tabulku řetězců šablon.

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

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

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 nelze použít, pokud používáte Vitest jako typový kontrolor.

describe.for

Alias: suite.for

Rozdíl od describe.each spočívá ve způsobu, jakým je pole předáváno v argumentech. Ostatní argumenty, které nejsou polem (včetně použití řetězce šablony), fungují přesně stejně.

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

// `for` nerozbaluje pole
describe.for([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('add(%i, %i) -> %i', ([a, b, expected]) => { 
  test('test', () => {
    expect(a + b).toBe(expected);
  });
});

Nastavení a vyčištění

Tyto funkce vám umožňují zasáhnout do životního cyklu testů, abyste se vyhnuli opakování kódu pro nastavení a vyčištění. Platí pro aktuální kontext: soubor, pokud jsou použity na nejvyšší úrovni, nebo aktuální sadu, pokud jsou uvnitř bloku describe. Tyto funkce zpětného volání nejsou volány, když spouštíte Vitest jako typový kontrolor.

beforeEach

Typ: beforeEach(fn: () => Awaitable<void>, timeout?: number)

Zaregistruje callback, který bude volán před spuštěním každého testu v aktuálním kontextu. Pokud funkce vrátí Promise, Vitest počká, dokud se Promise nevyřeší, před spuštěním testu.

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 () => {
  // Vymazat simulace a přidat nějaká testovací data před každým spuštěním testu
  await stopMocking();
  await addUser({ name: 'John' });
});

Zde beforeEach zajišťuje, že uživatel je přidán před každým testem.

beforeEach také přijímá volitelnou vyčišťovací funkci (ekvivalent afterEach).

import { beforeEach } from 'vitest';

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

  // vyčišťovací funkce, volána jednou po každém spuštění testu
  return async () => {
    await resetSomething();
  };
});

afterEach

Typ: afterEach(fn: () => Awaitable<void>, timeout?: number)

Zaregistruje callback, který bude volán po dokončení každého testu v aktuálním kontextu. Pokud funkce vrátí Promise, Vitest počká, dokud se Promise nevyřeší, než bude pokračovat.

Volitelně můžete poskytnout 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(); // vyčistit testovací data po každém spuštění testu
});

Zde afterEach zajišťuje, že testovací data jsou vymazána po každém spuštění testu.

TIP

Vitest 1.3.0 přidal funkci zpětného volání onTestFinished. Můžete ji volat během provádění testu k vyčištění libovolného stavu po dokončení testu.

beforeAll

Typ: beforeAll(fn: () => Awaitable<void>, timeout?: number)

Zaregistruje callback, který bude volán jednou před spuštěním všech testů v aktuálním kontextu. Pokud funkce vrátí Promise, Vitest počká, dokud se Promise nevyřeší, před spuštěním testů.

Volitelně můžete poskytnout 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 simulovaná data jsou nastavena před spuštěním testů.

beforeAll také přijímá volitelnou vyčišťovací funkci (ekvivalent afterAll).

import { beforeAll } from 'vitest';

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

  // vyčišťovací funkce, volána jednou po spuštění všech testů
  return async () => {
    await stopMocking();
  };
});

afterAll

Typ: afterAll(fn: () => Awaitable<void>, timeout?: number)

Zaregistruje callback, který bude volán jednou po spuštění všech testů v aktuálním kontextu. Pokud funkce vrátí Promise, Vitest počká, dokud se Promise nevyřeší, než bude pokračovat.

Volitelně můžete poskytnout 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ů.

Funkce zpětného volání testů

Vitest poskytuje několik funkcí zpětného volání, které můžete volat během provádění testu k vyčištění stavu po dokončení testu.

WARNING

Tyto funkce zpětného volání vyvolají chybu, pokud jsou volány mimo tělo testu.

onTestFinished

Tato funkce zpětného volání je vždy volána po dokončení testu. Je volána po funkcích zpětného volání afterEach, protože ty mohou ovlivnit výsledek testu. Přijímá objekt ExtendedContext stejně jako beforeEach a afterEach.

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 funkci zpětného volání onTestFinished z kontextu testu, protože Vitest nesleduje souběžné testy v globálních funkcích zpětného volání:

import { test } from 'vitest';

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

Tato funkce zpětného volání je obzvláš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

Tato funkce zpětného volání je vždy volána v opačném pořadí a není ovlivněna možností sequence.hooks.

onTestFailed

Tato funkce zpětného volání je volána pouze po selhání testu. Je volána po funkcích zpětného volání afterEach, protože ty mohou ovlivnit výsledek testu. Přijímá objekt ExtendedContext stejně jako beforeEach a afterEach. Tato funkce zpětného volání je užitečná pro ladění.

import { onTestFailed, test } from 'vitest';

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

WARNING

Pokud spouštíte testy souběžně, měli byste vždy používat funkci zpětného volání onTestFailed z kontextu testu, protože Vitest nesleduje souběžné testy v globálních funkcích zpětného volání:

import { test } from 'vitest';

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

Testovací reference API ​

test ​

test.extend ​

test.skip ​

test.skipIf ​

test.runIf ​

test.only ​

test.concurrent ​

test.sequential ​

test.todo ​

test.fails ​

test.each ​

test.for ​

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 ​

describe.for ​

Nastavení a vyčištění ​

beforeEach ​

afterEach ​

beforeAll ​

afterAll ​

Funkce zpětného volání testů ​

onTestFinished ​

onTestFailed ​

Testovací reference API

test

test.extend

test.skip

test.skipIf

test.runIf

test.only

test.concurrent

test.sequential

test.todo

test.fails

test.each

test.for

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

describe.for

Nastavení a vyčištění

beforeEach

afterEach

beforeAll

afterAll

Funkce zpětného volání testů

onTestFinished

onTestFailed