Funkce

• Konfigurace, transformátory, resolvátory a pluginy Vite
• Použijte stejné nastavení jako ve vaší aplikaci pro spouštění testů!
• Chytrý a okamžitý režim sledování, podobně jako HMR pro testy!
• Testování komponent pro Vue, React, Svelte, Lit, Marko a další technologie
• Nativní podpora TypeScriptu / JSX
• ESM na prvním místě, top-level await
• Vícevláknové zpracování pomocí Tinypool
• Podpora benchmarkingu pomocí Tinybench
• Filtrování, časové limity a souběžné spouštění pro sady a testy
• Podpora pracovního prostoru
• Jest-kompatibilní snapshoty
• Chai je vestavěný pro aserce + Jest expect kompatibilní API
• Tinyspy je vestavěný pro mocking
• happy-dom nebo jsdom pro DOM mocking
• Režim prohlížeče pro spouštění testů komponent v prohlížeči
• Pokrytí kódu pomocí v8 nebo istanbul
• In-source testování (podobné Rustu)
• Testování typů pomocí expect-type
• Podpora sharding

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

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

Vitest využívá konfiguraci, transformátory, resolvátory a pluginy Vite. Použijte stejné nastavení jako ve vaší aplikaci pro spouštění testů.

Více se dozvíte v Konfigurace Vitestu.

Režim sledování

$ vitest

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

vitest se ve výchozím nastavení spouští v watch mode ve vývojovém prostředí a v run mode v CI prostředí (když je přítomno process.env.CI). Můžete použít vitest watch nebo vitest run k explicitnímu určení požadovaného režimu.

Spusťte Vitest s příznakem --standalone, aby běžel na pozadí. Nebude spouštět žádné testy, dokud se nezmění. Vitest nespustí testy při změně zdrojového kódu, dokud se nespustí test, který tento zdroj importuje.

Běžné webové idiomy ihned po vybalení

Nativní podpora ES modulů / TypeScriptu / JSX / PostCSS

Vlákna

Ve výchozím nastavení Vitest spouští testovací soubory ve více procesech pomocí node:child_process přes Tinypool (odlehčená odnož Piscina), což umožňuje souběžné spouštění testů. Pokud chcete svou testovací sadu ještě více urychlit, zvažte povolení --pool=threads pro spouštění testů pomocí node:worker_threads (mějte na paměti, že některé balíčky nemusí s tímto nastavením fungovat).

Pro spouštění testů v jednom vlákně nebo procesu viz 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 (na úkor správnosti pro vyšší výkon).

Filtrování testů

Vitest nabízí mnoho způsobů, jak zúžit spouštěné testy, aby se urychlilo testování a vy se mohli soustředit na vývoj.

Více se dozvíte o Filtrování testů.

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

Použijte .concurrent u jednotlivých testů pro jejich paralelní spuštění.

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, 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. Více se dozvíte v API referenci.

WARNING

Při spouštění souběžných testů je nutné, aby Snapshoty a Aserce používaly expect z lokálního Testovacího kontextu, aby bylo zajištěno, že je detekován správný test.

Snapshot

Podpora snapshotů kompatibilních s Jestem.

import { expect, it } from 'vitest';

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

Více se dozvíte v Snapshot.

Kompatibilita Chai a Jest expect

Chai je vestavěný pro aserce a nabízí API Jest expect-kompatibilní.

Všimněte si, že pokud používáte knihovny třetích stran, které přidávají matchery, nastavení test.globals na true zajistí lepší kompatibilitu.

Mocking

Tinyspy je vestavěný pro mocking a nabízí jest-kompatibilní API 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: string) => arg);

fn('world', 2);

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

Vitest podporuje jak happy-dom, tak jsdom pro DOM mocking a mocking API prohlížeče. Nejsou součástí Vitestu, budete je muset nainstalovat samostatně:

$ npm i -D happy-dom
# nebo
$ 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', // nebo 'jsdom', 'node'
  },
});

Více se dozvíte v Mocking.

Pokrytí

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

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

Více se dozvíte v Pokrytí.

In-Source testování

Vitest také poskytuje způsob, jak spouštět testy uvnitř vašeho zdrojového kódu spolu s implementací, podobně jako modulové testy v Rustu.

Díky tomu testy sdílejí stejnou uzávěru jako implementace a umožňují testování soukromých stavů bez nutnosti exportu. Zároveň to také zkracuje cyklus zpětné vazby během vývoje.

// src/index.ts

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

// in-source testovací sady
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 se dozvíte v In-source testování.

Benchmarking Experimentální

Můžete spouštět benchmark testy pomocí funkce bench a knihovny Tinybench pro porovnání výsledků 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;
    });
  });
});

Testování typů Experimentální

Můžete psát testy pro odhalení regresí typů. Vitest obsahuje balíček expect-type, který poskytuje podobné a snadno srozumitelné API.

import { assertType, expectTypeOf, test } 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 musí být řetězec
  assertType(mount({ name: 42 }));
});

Sharding

Spouštějte testy na různých počítačích pomocí příznaků --shard a --reporter=blob. Všechny výsledky testů a pokrytí lze sloučit na konci vašeho CI pipeline pomocí příkazu --merge-reports:

vitest --shard=1/2 --reporter=blob
vitest --shard=2/2 --reporter=blob
vitest --merge-reports --reporter=junit --coverage.reporter=text

Více informací naleznete v Zlepšení výkonu | Sharding.

Proměnné prostředí

Vitest automaticky načítá proměnné prostředí s prefixem VITE_ ze souborů .env, aby zachoval kompatibilitu s testy souvisejícími s frontendem, v souladu s již zavedenou konvencí Vite. Chcete-li načíst všechny proměnné prostředí ze souborů .env, můžete použít metodu loadEnv importovanou z vite:

import { loadEnv } from 'vite';
import { defineConfig } from 'vitest/config';

export default defineConfig(({ mode }) => ({
  test: {
    // mode definuje, který soubor ".env.{mode}" vybrat, pokud existuje
    env: loadEnv(mode, process.cwd(), ''),
  },
}));