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)

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

Vícevláknové zpracování pomocí workerů přes Tinypool (odlehčená větev Piscina), umožňující souběžné spouštění testů. Vlákna jsou ve Vitest ve výchozím nastavení povolena a lze je zakázat předáním --no-threads v CLI.

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:

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

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

// vite.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.

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