Funkce

Vite konfigurace, transformátory, resolvery a pluginy.
Použijte stejné nastavení jako ve vaší aplikaci pro spouštění testů!
Rychlý a inteligentní režim sledování, fungující jako HMR pro testy!
Komponentové testování pro Vue, React, Svelte, Lit a další
Podpora TypeScript / JSX ihned po instalaci
ESM first, top level await
Vícevláknové zpracování pomocí workerů přes Tinypool
Podpora benchmarkingu s Tinybench
Filtrování, časové limity a souběžnost pro testy a testovací sady
Podpora pracovního prostoru (Workspace)
Snapshoty kompatibilní s Jestem
Vestavěný Chai pro tvrzení (assertions) + API kompatibilní s Jest expect
Vestavěný Tinyspy pro mocking
happy-dom nebo jsdom pro DOM mocking
Pokrytí kódu přes v8 nebo istanbul
Testování přímo ve zdrojovém kódu ve stylu Rustu (in-source testing)
Testování typů přes expect-type

Naučte se napsat svůj první test pomocí videa

Sdílená konfigurace mezi testy, vývojem a sestavením

Vite konfigurace, transformátory, resolvery a pluginy. Použijte stejné nastavení jako ve vaší aplikaci pro spouštění testů.

Více informací najdete v Konfiguraci Vitestu.

Režim sledování (Watch Mode)

bash

$ vitest

Když upravíte zdrojový kód nebo testovací soubory, Vitest inteligentně prohledá graf modulů a znovu spustí pouze související testy, stejně jako funguje HMR ve Vite!

vitest se spouští v režimu sledování ve vývojovém prostředí ve výchozím nastavení a v režimu spuštění v CI prostředí (pokud je přítomna proměnná prostředí process.env.CI). Můžete použít vitest watch nebo vitest run k explicitnímu určení požadovaného režimu.

Běžné webové postupy ihned po instalaci

Podpora ES modulů / TypeScript / JSX / PostCSS ihned po instalaci.

Vlákna (Threads)

Ve výchozím nastavení Vitest spouští testovací soubory ve více vláknech pomocí node:worker_threads prostřednictvím Tinypool (odlehčená větev Piscina), což umožňuje spouštět testy současně. Pokud váš testovací kód není kompatibilní s vícevláknovým zpracováním, můžete přepnout na --pool=forks, který spouští testy ve více procesech pomocí node:child_process prostřednictvím Tinypool.

Chcete-li spustit testy v jednom vlákně nebo procesu, podívejte se na poolOptions.

Vitest také izoluje prostředí každého souboru, takže mutace prostředí v jednom souboru neovlivňují ostatní. Izolaci lze zakázat předáním --no-isolate do CLI (obětování správnosti za vyšší výkon).

Filtrování testů

Vitest poskytuje mnoho způsobů, jak zúžit sadu spouštěných testů, a tím urychlit testování a umožnit soustředit se na vývoj.

Více informací o Filtrování testů.

Souběžné spouštění testů

Použijte .concurrent u po sobě jdoucích testů ke spuštění paralelně.

import { describe, it } from 'vitest';

// Dva testy označené jako concurrent budou spuštěny paralelně
describe('suite', () => {
  it('serial test', async () => {
    /* ... */
  });
  it.concurrent('concurrent test 1', async ({ expect }) => {
    /* ... */
  });
  it.concurrent('concurrent test 2', async ({ expect }) => {
    /* ... */
  });
});

Pokud použijete .concurrent na sadu (suite), každý test v ní bude spuštěn paralelně.

import { describe, it } from 'vitest';

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

Můžete také použít .skip, .only a .todo se souběžnými sadami a testy. Přečtěte si více v API Reference.

WARNING

Při spouštění souběžných testů musí snapshoty a assertion používat expect z lokálního Test Context, aby bylo zajištěno, že je detekován správný test.

Snapshoty

Podpora snapshotů kompatibilních s Jestem.

import { expect, it } from 'vitest';

it('renders correctly', () => {
  const result = render();
  expect(result).toMatchSnapshot();
});

Více informací naleznete v Snapshot.

Kompatibilita Chai a Jest `expect`

Vestavěný Chai pro tvrzení (assertions) plus API kompatibilní s Jest expect.

Všimněte si, že nastavením test.globals na true dosáhnete lepší kompatibility, pokud používáte knihovny třetích stran, které přidávají matchers (porovnávače).

Mocking

Vestavěný Tinyspy pro mocking s API kompatibilním s jest na objektu vi.

import { expect, vi } from 'vitest';

const fn = vi.fn();

fn('hello', 1);

expect(vi.isMockFunction(fn)).toBe(true);
expect(fn.mock.calls[0]).toEqual(['hello', 1]);

fn.mockImplementation(arg => arg);

fn('world', 2);

expect(fn.mock.results[1].value).toBe('world');

Vitest podporuje jak happy-dom nebo jsdom pro DOM mocking a browser API. Nejsou součástí Vitest, možná je budete muset nainstalovat:

bash

$ npm i -D happy-dom
# or
$ npm i -D jsdom

Poté změňte možnost environment ve vašem konfiguračním souboru:

// vitest.config.ts
import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    environment: 'happy-dom', // or 'jsdom', 'node'
  },
});

Více informací naleznete v Mocking.

Coverage (Pokrytí kódu)

Vitest podporuje nativní pokrytí kódu pomocí v8 a instrumentované pokrytí kódu pomocí istanbul.

json

{
  "scripts": {
    "test": "vitest",
    "coverage": "vitest run --coverage"
  }
}

Více informací naleznete v Coverage.

In-source testing

Vitest také poskytuje způsob, jak spouštět testy ve vašem zdrojovém kódu spolu s implementací, podobně jako modulové testy Rustu.

Díky tomu testy sdílejí stejný closure jako implementace a mohou testovat proti soukromým stavům bez nutnosti exportu. Mezitím také přináší užší zpětnovazební smyčku pro vývoj.

// src/index.ts

// implementace
export function add(...args: number[]) {
  return args.reduce((a, b) => a + b, 0);
}

// in-source test suites
if (import.meta.vitest) {
  const { it, expect } = import.meta.vitest;
  it('add', () => {
    expect(add()).toBe(0);
    expect(add(1)).toBe(1);
    expect(add(1, 2, 3)).toBe(6);
  });
}

Více informací naleznete v In-source testing.

Benchmarking Experimental

Od verze Vitest 0.23.0 můžete používat funkci bench s knihovnou Tinybench k benchmarkingu a porovnávání výkonu.

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

Type Testing Experimental

Od Vitest 0.25.0 můžete psát testy pro zachycení typových regresí. Vitest je dodáván s balíčkem expect-type, který vám poskytne podobné a snadno srozumitelné API.

import { assertType, expectTypeOf } from 'vitest';
import { mount } from './mount.js';

test('my types work properly', () => {
  expectTypeOf(mount).toBeFunction();
  expectTypeOf(mount).parameter(0).toMatchTypeOf<{ name: string }>();

  // @ts-expect-error name is a string
  assertType(mount({ name: 42 }));
});

Funkce ​

Sdílená konfigurace mezi testy, vývojem a sestavením ​

Režim sledování (Watch Mode) ​

Běžné webové postupy ihned po instalaci ​

Vlákna (Threads) ​

Filtrování testů ​

Souběžné spouštění testů ​

Snapshoty ​

Kompatibilita Chai a Jest expect ​

Mocking ​

Coverage (Pokrytí kódu) ​

In-source testing ​

Benchmarking Experimental ​

Type Testing Experimental ​