Funkce

• Konfigurace, transformátory, resolvery a pluginy pro Vite
• Využívá stejné nastavení jako vaše aplikace pro spouštění testů.
• Inteligentní a okamžitý režim sledování, podobný HMR pro testy.
• Testování komponent pro Vue, React, Svelte, Lit, Marko a další.
• Vestavěná podpora TypeScript a JSX.
• Priorita ESM, podpora top-level await.
• Vícevláknové zpracování pomocí Tinypool.
• Podpora benchmarkingu s Tinybench.
• Filtrování, časové limity, souběžné spouštění testů a sad.
• Podpora pro projekty.
• Snapshoty kompatibilní s Jest.
• Chai vestavěný pro asertace + Jest expect kompatibilní API.
• Tinyspy vestavěný pro simulaci (mocking).
• happy-dom nebo jsdom pro simulaci DOM.
• Režim prohlížeče pro spouštění testů komponent v prohlížeči.
• Pokrytí kódu pomocí v8 nebo istanbul.
• Testování ve zdrojovém kódu jako v Rustu.
• Testování typů pomocí expect-type.
• Podpora sharding.
• Hlášení neošetřených chyb.

Naučte se psát svůj první test pomocí videa

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

Vitest využívá konfiguraci, transformátory, resolvery a pluginy z Vite. To umožňuje použít stejné nastavení z vaší aplikace pro spouštění testů.

Více informací naleznete v Konfigurace Vitest.

Režim sledování

$ vitest

Pokud upravíte svůj 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 ve vývojovém prostředí spouští ve výchozím nastavení v watch mode a v CI prostředí (když je přítomno process.env.CI) se inteligentně přepne do run mode. Můžete použít vitest watch nebo vitest run pro explicitní 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, pokud se změní zdrojový kód, dokud se nespustí test, který tento zdroj importuje.

Běžné webové idiomy ihned k použití

Podpora ES Modulů / TypeScript / JSX / PostCSS je k dispozici ihned po instalaci.

Vlákna

Ve výchozím nastavení Vitest spouští testovací soubory ve více procesech pomocí node:child_process přes Tinypool (odlehčenou odnož Piscina), což umožňuje souběžné spouštění testů. Pokud chcete ještě více zrychlit svou testovací sadu, 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 spuš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 příkazového řádku (což obětuje správnost ve prospěch výkonu).

Filtrování testů

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

Více informací naleznete 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';

// Oba testy označené concurrent se spustí 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';

// All tests within this suite will be started in parallel
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ů musí Snapshots a Assertions používat expect z lokálního Test Contextu, aby bylo zajištěno, že je detekován správný test.

Snapshot

Podpora snapshotů, které jsou kompatibilní s Jest.

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 asertace s API kompatibilními s Jest expect.

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

Mocking

Tinyspy je vestavěný pro simulaci (mocking) s jest-kompatibilními 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 simulaci DOM a API prohlížeče. Nejsou součástí Vitestu, musíte je nainstalovat samostatně:

happy-dom

$ npm i -D happy-dom

jsdom

$ npm i -D jsdom

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

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    environment: 'happy-dom', // or '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í.

Testování ve zdrojovém kódu

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

Díky tomu testy sdílejí stejnou uzávěru jako implementace a mohou testovat soukromé stavy bez exportu. Zároveň to také zrychluje zpětnou vazbu během vývoje.

// the implementation
export function add(...args: number[]): 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 se dozvíte v Testování ve zdrojovém kódu.

Benchmarking Experimentální

Můžete spouštět benchmarkové testy s funkcí bench pomocí Tinybench pro porovnání výkonových výsledků.

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 přichází s balíčkem expect-type, který vám poskytuje podobné a snadno pochopitelné 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 is a string
  assertType(mount({ name: 42 }));
});

Sharding

Spouštějte testy na různých strojí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 --coverage
vitest --shard=2/2 --reporter=blob --coverage
vitest --merge-reports --reporter=junit --coverage

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

Proměnné prostředí

Vitest automaticky načítá proměnné prostředí, které mají prefix VITE_ ze souborů .env, aby zachoval kompatibilitu s testy souvisejícími s frontendem, v souladu s ustálenou konvencí Vite. Pokud chcete načíst všechny proměnné prostředí ze souborů .env, můžete použít metodu loadEnv importovanou z balíčku vite:

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

export default defineConfig(({ mode }) => ({
  test: {
    // Režim definuje, jaký soubor ".env.{mode}" se vybere, pokud existuje.
    env: loadEnv(mode, process.cwd(), ''),
  },
}));

Nezpracované chyby

Ve výchozím nastavení Vitest zachycuje a hlásí všechna neošetřená odmítnutí, nezachycené výjimky (v Node.js) a chybové události (v prohlížeči).

Toto chování můžete zakázat jejich ručním zachycením. Vitest předpokládá, že zpětné volání zpracováváte vy, a chybu nenahlásí.

setup.node.js

// v Node.js
process.on('unhandledRejection', () => {
  // váš vlastní handler
});

process.on('uncaughtException', () => {
  // váš vlastní handler
});

setup.browser.js

// v prohlížeči
window.addEventListener('error', () => {
  // váš vlastní handler
});

window.addEventListener('unhandledrejection', () => {
  // váš vlastní handler
});

Alternativně můžete také ignorovat hlášené chyby s možností dangerouslyIgnoreUnhandledErrors. Vitest je stále nahlásí, ale neovlivní výsledek testu (návratový kód se nezmění).

Pokud potřebujete otestovat, že chyba nebyla ošetřena, můžete vytvořit test, který vypadá takto:

test('my function throws uncaught error', async ({ onTestFinished }) => {
  onTestFinished(() => {
    // pokud událost nebyla během testu nikdy zavolána,
    // ujistěte se, že je odstraněna před začátkem dalšího testu
    process.removeAllListeners('unhandledrejection');
  });

  return new Promise((resolve, reject) => {
    process.once('unhandledrejection', error => {
      try {
        expect(error.message).toBe('my error');
        resolve();
      } catch (error) {
        reject(error);
      }
    });

    callMyFunctionThatRejectsError();
  });
});