Konfigurace Vitest

Konfigurace

vitest načte kořenový soubor vite.config.ts, pokud existuje, a použije jej pro konfiguraci pluginů a nastavení vaší Vite aplikace. Pokud potřebujete pro testování jinou konfiguraci, nebo se vaše hlavní aplikace nespoléhá na Vite, můžete:

Vytvořit soubor vitest.config.ts, který má vyšší prioritu a přepíše konfiguraci z vite.config.ts.
Předat argument --config do příkazového řádku (CLI), např. vitest --config ./path/to/vitest.config.ts.
Použít process.env.VITEST nebo vlastnost mode v defineConfig (bude nastavena na test/benchmark, pokud nebude přepsána) pro podmíněné použití jiné konfigurace v vite.config.ts.

Pro konfiguraci samotného vitest přidejte vlastnost test do konfigurace Vite. Pokud importujete defineConfig přímo z vite, přidejte na začátek konfiguračního souboru odkaz na typy Vitest pomocí příkazu se třemi lomítky.

Při použití defineConfig z vite postupujte následovně:

/// <reference types="vitest" />
import { defineConfig } from 'vite';

export default defineConfig({
  test: {
    // ...
  },
});

Při použití defineConfig z vitest/config byste měli postupovat takto:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    // ...
  },
});

Můžete načíst výchozí nastavení Vitest a v případě potřeby je rozšířit:

import { configDefaults, defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    exclude: [...configDefaults.exclude, 'packages/template/*'],
  },
});

Pokud používáte samostatný vitest.config.js, můžete v případě potřeby rozšířit nastavení Vite z jiného konfiguračního souboru:

import { defineConfig, mergeConfig } from 'vitest/config';
import viteConfig from './vite.config';

export default mergeConfig(
  viteConfig,
  defineConfig({
    test: {
      exclude: ['packages/template/*'],
    },
  })
);

WARNING

mergeConfig je k dispozici ve Vitest od verze v0.30.0. Pokud používáte nižší verzi, můžete jej importovat přímo z vite.

Pokud je vaše konfigurace Vite definována jako funkce, můžete ji definovat takto:

import { defineConfig, mergeConfig } from 'vitest/config';
import viteConfig from './vite.config';

export default defineConfig(configEnv =>
  mergeConfig(
    viteConfig(configEnv),
    defineConfig({
      test: {
        exclude: ['packages/template/*'],
      },
    })
  )
);

Možnosti

TIP

Kromě následujících možností můžete použít i libovolnou možnost konfigurace z Vite. Například define pro definování globálních proměnných nebo resolve.alias pro definování aliasů.

TIP

U všech možností konfigurace, které nejsou podporovány v konfiguraci pracovního prostoru, je uvedena značka *.

include

Typ: string[]
Výchozí: ['**/*.{test,spec}.?(c|m)[jt]s?(x)']

Vzory globů pro soubory, které se mají zahrnout do testů.

exclude

Typ: string[]
Výchozí: ['**/node_modules/**', '**/dist/**', '**/cypress/**', '**/.{idea,git,cache,output,temp}/**', '**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build}.config.*']

Vzory globů pro soubory, které se mají vyloučit z testů.

includeSource

Typ: string[]
Výchozí: []

Vzory globů pro zdrojové soubory testů.

Když je tato možnost definována, Vitest spustí všechny odpovídající soubory s import.meta.vitest uvnitř.

server

Typ: { sourcemap?, deps?, ... }
Verze: Od Vitest 0.34.0

Možnosti serveru Vite-Node.

server.sourcemap

Typ: 'inline' | boolean
Výchozí: 'inline'

Vložit inline sourcemap do modulů.

server.debug

Typ: { dumpModules?, loadDumppedModules? }

Možnosti ladění Vite-Node.

server.debug.dumpModules

Typ: boolean | string

Uloží transformovaný modul do systému souborů. Pokud je zadán řetězec, modul se uloží do dané cesty.

server.debug.loadDumppedModules

Typ: boolean

Načte uložený modul ze systému souborů, pokud existuje. Užitečné pro ladění úpravou výsledku uloženého modulu v systému souborů.

server.deps

Typ: { external?, inline?, ... }

Nastavení pro řešení závislostí.

server.deps.external

Typ: (string | RegExp)[]
Výchozí: [/\/node_modules\//]

Externalizace znamená, že Vite přeskočí zpracování balíčku a použije nativní Node. Externalizované závislosti nebudou ovlivněny transformátory a řešiteli Vite, takže nepodporují HMR při opětovném načtení. Ve výchozím nastavení jsou externalizovány všechny balíčky uvnitř node_modules.

Tyto možnosti podporují názvy balíčků tak, jak jsou zapsány v node_modules nebo zadány uvnitř deps.moduleDirectories. Například balíček @company/some-name umístěný uvnitř packages/some-name by měl být zadán jako some-name a packages by měly být zahrnuty do deps.moduleDirectories. Vitest v podstatě vždy kontroluje cestu k souboru, nikoli skutečný název balíčku.

Pokud se používá regulární výraz, Vitest jej volá na cestu k souboru, nikoli na název balíčku.

server.deps.inline

Typ: (string | RegExp)[] | true
Výchozí: []

Vite zpracovává vložené moduly. To je užitečné pro balíčky, které používají formát ESM (který Node nativně nepodporuje).

Pokud je hodnota true, bude vložena každá závislost. Všechny závislosti uvedené v ssr.noExternal budou ve výchozím nastavení vloženy.

server.deps.fallbackCJS

Typ: boolean
Výchozí: false

Pokud je závislost platný balíček ESM, pokuste se určit verzi CJS podle cesty. To může být užitečné, pokud má závislost nesprávný soubor ESM.

To může potenciálně způsobit určité nesrovnalosti, pokud má balíček odlišnou logiku v režimu ESM a CJS.

server.deps.cacheDir

Typ: string
Výchozí: 'node_modules/.vite'

Adresář pro uložení souborů mezipaměti.

deps

Typ: { optimizer?, registerNodeLoader?, ... }

Nastavení pro řešení závislostí.

deps.optimizer

Typ: { ssr?, web? }
Verze: Od Vitest 0.34.0
Viz také: Možnosti optimalizace závislostí

Povolit optimalizaci závislostí. Pokud máte hodně testů, může to zlepšit jejich výkon. Před Vitest 0.34.0 se to jmenovalo deps.experimentalOptimizer.

Pokud Vitest najde externí knihovnu uvedenou v include, sváže ji do jednoho souboru pomocí esbuild a importuje ji jako modul. To je dobré z několika důvodů:

Import balíčků s velkým počtem importů je náročný. Seskupením do jednoho souboru můžeme ušetřit čas.
Import knihoven UI je nákladný, protože nejsou určeny ke spuštění uvnitř Node.js.
Konfigurace alias je nyní respektována i uvnitř svázaných balíčků.
Kód v testech se spouští podobně jako v prohlížeči.

Uvědomte si, že jsou svázány pouze balíčky v možnosti deps.optimizer?.[mode].include (některé pluginy to vyplňují automaticky, jako Svelte). Více o dostupných možnostech si můžete přečíst v dokumentech Vite (Vitest nepodporuje možnosti disable a noDiscovery). Ve výchozím nastavení používá Vitest optimizer.web pro prostředí jsdom a happy-dom a optimizer.ssr pro prostředí node a edge, ale je konfigurovatelné pomocí transformMode.

Tato možnost také dědí vaši konfiguraci optimizeDeps (pro web Vitest rozšíří optimizeDeps, pro ssr - ssr.optimizeDeps). Pokud předefinujete možnost include/exclude v deps.optimizer, rozšíří to vaše optimizeDeps při spouštění testů. Vitest automaticky odebere stejné možnosti z include, pokud jsou uvedeny v exclude.

TIP

Nebudete moci upravovat kód node_modules pro ladění, protože kód se ve skutečnosti nachází ve vašem adresáři cacheDir nebo test.cache.dir. Pokud chcete ladit pomocí příkazů console.log, upravte jej přímo nebo vynuťte opětovné svázání pomocí možnosti deps.optimizer?.[mode].force.

deps.optimizer.{mode}.enabled

Typ: boolean
Výchozí: true, pokud používáte >= Vite 4.3.2, false jinak

Povolit optimalizaci závislostí.

WARNING

Tato možnost funguje pouze s Vite verze 4.3.2 a vyšší.

deps.web

Typ: { transformAssets?, ... }
Verze: Od Vite 0.34.2

Možnosti aplikované na externí soubory, když je režim transformace nastaven na web. Ve výchozím nastavení používají jsdom a happy-dom režim web, zatímco prostředí node a edge používají režim transformace ssr, takže tyto možnosti nebudou mít žádný vliv na soubory uvnitř těchto prostředí.

Soubory uvnitř node_modules jsou obvykle externalizovány, ale tyto možnosti ovlivňují také soubory v server.deps.external.

deps.web.transformAssets

Typ: boolean
Výchozí: true

Má Vitest zpracovávat soubory aktiv (.png, .svg, .jpg atd.) a řešit je stejně jako Vite v prohlížeči?

Tento modul bude mít výchozí export odpovídající cestě k assetu, pokud není zadán žádný dotaz.

WARNING

V současné době tato možnost funguje pouze s fondem experimentalVmThreads.

deps.web.transformCss

Typ: boolean
Výchozí: true

Má Vitest zpracovávat CSS soubory (.css, .scss, .sass atd.) a řešit je stejně jako Vite v prohlížeči?

Pokud jsou CSS soubory zakázány pomocí možností css, tato možnost pouze potlačí chyby ERR_UNKNOWN_FILE_EXTENSION.

WARNING

V současné době tato možnost funguje pouze s fondem experimentalVmThreads.

deps.web.transformGlobPattern

Typ: RegExp | RegExp[]
Výchozí: []

Regulární výraz pro porovnání externích souborů, které by měly být transformovány.

Ve výchozím nastavení jsou soubory uvnitř node_modules externalizovány a netransformovány, pokud se nejedná o CSS nebo aktivum a odpovídající možnost není zakázána.

WARNING

V současné době tato možnost funguje pouze s fondem experimentalVmThreads.

deps.registerNodeLoader*

Typ: boolean
Výchozí: false

Používá se experimentální Node loader k řešení importů v externalizovaných souborech pomocí algoritmu Vite?

Pokud je tato možnost zakázána, váš alias a <plugin>.resolveId neovlivní importy uvnitř externalizovaných balíčků (ve výchozím nastavení node_modules).

deps.interopDefault

Typ: boolean
Výchozí: true

Interpretuje výchozí export modulu CJS jako pojmenované exporty. Některé závislosti pouze obsahují moduly CJS a nepoužívají pojmenované exporty, které Node.js může staticky analyzovat, když je balíček importován pomocí syntaxe import místo require. Při importu těchto závislostí v Node.js prostředí pomocí pojmenovaných exportů se zobrazí tato chyba:

import { read } from 'fs-jetpack';
         ^^^^
SyntaxError: Named export 'read' not found. The requested module 'fs-jetpack' is a CommonJS module, which may not support all module.exports as named exports.
CommonJS modules can always be imported via the default export.

Vitest neprovádí statickou analýzu a nemůže selhat před spuštěním kódu, takže tuto chybu s největší pravděpodobností uvidíte při spouštění testů, pokud je tato funkce zakázána:

TypeError: createAsyncThunk is not a function
TypeError: default is not a function

Ve výchozím nastavení Vitest předpokládá, že používáte bundler k obejití tohoto a neselže, ale toto chování můžete zakázat ručně, pokud váš kód není zpracován.

deps.moduleDirectories

Typ: string[]
Výchozí: ['node_modules']

Seznam adresářů, které mají být považovány za adresáře modulů. Tato konfigurační možnost ovlivňuje chování vi.mock: pokud není zadána tovární funkce a cesta k mockovanému modulu odpovídá jedné z hodnot moduleDirectories, Vitest se pokusí najít mock ve složce __mocks__ v kořenovém adresáři projektu.

Tato možnost také ovlivní, zda by měl být soubor považován za modul při externalizaci závislostí. Ve výchozím nastavení Vitest importuje externí moduly s nativním Node.js obcházejícím krok transformace Vite.

Nastavení této možnosti přepíše výchozí nastavení. Pokud chcete i nadále hledat balíčky v node_modules, přidejte jej do seznamu spolu s dalšími adresáři:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    deps: {
      moduleDirectories: ['node_modules', path.resolve('../../packages')],
    },
  },
});

runner

Typ: VitestRunnerConstructor
Výchozí: node při spouštění testů, nebo benchmark při spouštění benchmarků

Cesta k vlastním spouštěčům testů. Jedná se o pokročilou funkci a měla by být používána s vlastními spouštěči knihoven. Více si o tom můžete přečíst v dokumentaci.

benchmark

Typ: { include?, exclude?, ... }

Možnosti použité při spuštění vitest bench.

benchmark.include

Typ: string[]
Výchozí: ['**/*.{bench,benchmark}.?(c|m)[jt]s?(x)']

Vzory globů pro soubory benchmark testů.

benchmark.exclude

Typ: string[]
Výchozí: ['node_modules', 'dist', '.idea', '.git', '.cache']

Vzory globů pro vyloučení souborů benchmark testů.

benchmark.includeSource

Typ: string[]
Výchozí: []

Vzory globů pro zdrojové soubory benchmark testů. Tato možnost je podobná includeSource.

Když je tato možnost definována, Vitest spustí všechny odpovídající soubory s import.meta.vitest uvnitř.

benchmark.reporters

Typ: Arrayable<BenchmarkBuiltinReporters | Reporter>
Výchozí: 'default'

Vlastní reportér pro výstup. Může obsahovat jeden nebo více vestavěných názvů reportů, instance reportérů a/nebo cesty k vlastním reportérům.

benchmark.outputFile

Typ: string | Record<string, string>

Zapsat výsledky benchmarku do souboru, když je také zadána možnost --reporter=json. Poskytnutím objektu namísto řetězce můžete definovat jednotlivé výstupy při použití více reportérů.

Chcete-li poskytnout objekt prostřednictvím příkazu CLI, použijte následující syntaxi: --outputFile.json=./path --outputFile.junit=./other-path.

alias

Typ: Record<string, string> | Array<{ find: string | RegExp, replacement: string, customResolver?: ResolverFunction | ResolverObject }>

Definovat vlastní aliasy při spuštění testů. Budou sloučeny s aliasy z resolve.alias.

globals

Typ: boolean
Výchozí: false
CLI: --globals, --globals=false

Ve výchozím nastavení vitest neposkytuje globální API, aby byla zajištěna explicitnost. Pokud preferujete používání API globálně jako v Jest, můžete předat možnost --globals do CLI nebo přidat globals: true v konfiguraci.

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

export default defineConfig({
  test: {
    globals: true,
  },
});

Aby TypeScript fungoval s globálními API, přidejte vitest/globals do pole types ve vašem tsconfig.json

json

// tsconfig.json
{
  "compilerOptions": {
    "types": ["vitest/globals"]
  }
}

Pokud již ve svém projektu používáte unplugin-auto-import, můžete jej také použít přímo pro automatický import těchto API.

// vite.config.ts
import { defineConfig } from 'vitest/config';
import AutoImport from 'unplugin-auto-import/vite';

export default defineConfig({
  plugins: [
    AutoImport({
      imports: ['vitest'],
      dts: true, // generate TypeScript declaration
    }),
  ],
});

environment

Typ: 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime' | string
Výchozí hodnota: 'node'
CLI: --environment=<env>

Prostředí, ve kterém se testy spouštějí. Vitest ve výchozím nastavení používá prostředí Node.js. Pro vývoj webových aplikací můžete použít prostředí simulující prohlížeč, a to buď pomocí jsdom nebo happy-dom. Pro edge funkce je k dispozici prostředí edge-runtime.

Pro definování prostředí pro konkrétní soubor s testy můžete použít docblock nebo komentář @vitest-environment na začátku souboru:

Styl Docblock:

/**
 * @vitest-environment jsdom
 */

test('use jsdom in this test file', () => {
  const element = document.createElement('div');
  expect(element).not.toBeNull();
});

Styl komentáře:

// @vitest-environment happy-dom

test('use happy-dom in this test file', () => {
  const element = document.createElement('div');
  expect(element).not.toBeNull();
});

Pro kompatibilitu s Jestem je podporován i @jest-environment:

/**
 * @jest-environment jsdom
 */

test('use jsdom in this test file', () => {
  const element = document.createElement('div');
  expect(element).not.toBeNull();
});

Při spuštění Vitestu s příznakem --threads=false budou testy spouštěny v následujícím pořadí prostředí: node, jsdom, happy-dom, edge-runtime, vlastní prostředí. Testy se stejným prostředím budou seskupeny a spouštěny sekvenčně.

Od verze 0.23.0 je možné definovat vlastní prostředí. Pokud je použito jiné než vestavěné prostředí, Vitest se pokusí načíst balíček vitest-environment-${name}. Tento balíček by měl exportovat objekt typu Environment:

import type { Environment } from 'vitest';

export default <Environment>{
  name: 'custom',
  transformMode: 'ssr',
  setup() {
    // custom setup
    return {
      teardown() {
        // called after all tests with this env have been run
      },
    };
  },
};

Vitest také zpřístupňuje builtinEnvironments prostřednictvím vstupu vitest/environments, pokud je chcete rozšířit. Více informací o rozšiřování prostředí naleznete v našem průvodci.

environmentOptions

Typ: Record<'jsdom' | string, unknown>
Výchozí: {}

Tyto volby jsou předány metodě setup aktuálního environment. Ve výchozím nastavení můžete konfigurovat pouze možnosti JSDOM, pokud jej používáte jako testovací prostředí.

environmentMatchGlobs

Typ: [string, EnvironmentName][]
Výchozí: []

Automaticky přiřadí prostředí na základě globů. Použije se první odpovídající glob.

Například:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    environmentMatchGlobs: [
      // all tests in tests/dom will run in jsdom
      ['tests/dom/**', 'jsdom'],
      // all tests in tests/ with .edge.test.ts will run in edge-runtime
      ['**/*.edge.test.ts', 'edge-runtime'],
      // ...
    ],
  },
});

poolMatchGlobs

Typ: [string, 'threads' | 'child_process' | 'experimentalVmThreads'][]
Výchozí: []
Verze: Od Vitest 0.29.4

Automaticky přiřadí pool, ve kterém budou testy spuštěny, na základě globů. Použije se první odpovídající glob.

Například:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolMatchGlobs: [
      // all tests in "worker-specific" directory will run inside a worker as if you enabled `--threads` for them,
      ['**/tests/worker-specific/**', 'threads'],
      // run all tests in "browser" directory in an actual browser
      ['**/tests/browser/**', 'browser'],
      // all other tests will run based on "browser.enabled" and "threads" options, if you didn't specify other globs
      // ...
    ],
  },
});

update*

Typ: boolean
Výchozí: false
CLI: -u, --update, --update=false

Aktualizuje snapshot soubory. Aktualizují se všechny změněné snapshoty a odstraní se zastaralé.

watch*

Typ: boolean
Výchozí: true
CLI: -w, --watch, --watch=false

Povolí režim sledování (watch mode).

root

Typ: string
CLI: -r <path>, --root=<path>

Kořenový adresář projektu.

reporters*

Typ: Reporter | Reporter[]
Výchozí: 'default'
CLI: --reporter=<name>, --reporter=<name1> --reporter=<name2>

Vlastní reportéři pro výstup. Reportéři mohou být instance Reporter nebo řetězec pro výběr vestavěných reportérů:

'default' - sbalí sady, když projdou
'basic' - poskytuje reportér podobný výchozímu reportéru v CI
'verbose' - ponechá celý strom úloh viditelný
'dot' - zobrazí každou úlohu jako jednu tečku
'junit' - JUnit XML reportér (můžete konfigurovat název tagu testsuites pomocí proměnné prostředí VITEST_JUNIT_SUITE_NAME a vlastnost tagu classname pomocí VITEST_JUNIT_CLASSNAME)
'json' - poskytuje jednoduchý JSON souhrn
'html' - vypíše HTML report založený na @vitest/ui
'hanging-process' - zobrazí seznam visících procesů, pokud Vitest nemůže bezpečně ukončit proces. To může být náročná operace, povolte ji pouze v případě, že Vitest trvale nemůže ukončit proces
cesta k vlastnímu reportéru (např. './path/to/reporter.ts', '@scope/reporter')

outputFile*

Typ: string | Record<string, string>
CLI: --outputFile=<path>, --outputFile.json=./path

Zapíše výsledky testů do souboru, pokud je zadána možnost --reporter=json, --reporter=html nebo --reporter=junit. Poskytnutím objektu namísto řetězce můžete definovat jednotlivé výstupy pro různé reportéry.

experimentalVmThreads

Typ: boolean
CLI: --experimentalVmThreads, --experimental-vm-threads
Verze: Od Vitest 0.34.0

Umožňuje rychlejší běh testů pomocí VM context (uvnitř sandboxovaného prostředí) v poolu workerů.

Díky tomu běží testy rychleji, ale modul VM je nestabilní při spouštění ESM kódu. Může docházet k úniku paměti ve vašich testech - abyste s tím bojovali, zvažte ruční úpravu hodnoty experimentalVmWorkerMemoryLimit.

WARNING

Spouštění kódu v sandboxu má některé výhody (rychlejší testy), ale také přichází s řadou nevýhod.

Globální proměnné v nativních modulech, jako jsou (fs, path atd.), se liší od globálních proměnných přítomných ve vašem testovacím prostředí. V důsledku toho bude jakákoli chyba vyvolaná těmito nativními moduly odkazovat na jiný konstruktor Error ve srovnání s tím, který je použit ve vašem kódu:

try {
  fs.writeFileSync('/doesnt exist');
} catch (err) {
  console.log(err instanceof Error); // false
}

Importování ES modulů je ukládá do mezipaměti na neurčito, což způsobuje úniky paměti, pokud máte mnoho kontextů (testovacích souborů). V Node.js neexistuje žádné API, které by tuto mezipaměť vymazalo.
Přístup ke globálním proměnným trvá déle v sandboxovém prostředí.

Při použití této volby mějte prosím na paměti tyto problémy. Tým Vitest nemůže na naší straně žádný z těchto problémů vyřešit.

experimentalVmWorkerMemoryLimit

Typ: string | number
CLI: --experimentalVmWorkerMemoryLimit, --experimental-vm-worker-memory-limit
Výchozí: 1 / Počet jader CPU
Verze: Od Vitest 0.34.0

Nastavuje paměťový limit pro workery před jejich recyklací. Tato hodnota silně závisí na vašem prostředí, takže je lepší ji zadat ručně, než se spoléhat na výchozí hodnotu.

Tato možnost ovlivňuje pouze workery, které spouštějí testy v VM context.

TIP

Implementace je založena na Jest's workerIdleMemoryLimit.

Limit lze zadat několika různými způsoby a ať už je výsledek jakýkoli, Math.floor se použije k jeho převedení na celočíselnou hodnotu:

<= 1 - Předpokládá se, že hodnota je procento systémové paměti. Takže 0,5 nastaví limit paměti workeru na polovinu celkové systémové paměti
\> 1 - Předpokládá se, že se jedná o pevnou hodnotu v bajtech. Kvůli předchozímu pravidlu, pokud byste chtěli hodnotu 1 bajt (nevím proč), mohli byste použít 1,1.
S jednotkami
- 50% - Stejně jako výše, procento celkové systémové paměti
- 100KB, 65MB atd. - S jednotkami pro označení pevného limitu paměti.
  - K / KB - Kilobajty (x1000)
  - KiB - Kibibajty (x1024)
  - M / MB - Megabajty
  - MiB - Mebibajty
  - G / GB - Gigabajty
  - GiB - Gibibajty

WARNING

Limit paměti založený na procentech nefunguje na Linux CircleCI workerech kvůli nesprávně hlášené systémové paměti.

threads

Typ: boolean
Výchozí: true
CLI: --threads, --threads=false

Povolí multi-threading pomocí tinypool (odlehčená větev Piscina). Před Vitest 0.29.0 Vitest stále spouštěl testy uvnitř worker threadu, i když byla tato možnost zakázána. Od 0.29.0, pokud je tato možnost zakázána, Vitest používá child_process ke spuštění procesu pro spouštění testů uvnitř, což znamená, že můžete použít process.chdir a další API, které nebylo dostupné uvnitř workerů. Pokud se chcete vrátit k předchozímu chování, použijte místo toho možnost --single-thread.

Zakázáním této možnosti se všechny testy spouštějí uvnitř více podřízených procesů.

singleThread

Typ: boolean
Výchozí: false
Verze: Od Vitest 0.29.0

Spouští všechny testy se stejným prostředím uvnitř jednoho worker threadu. Tím se zakáže vestavěná izolace modulů (váš zdrojový kód nebo inlined kód bude stále přehodnocen pro každý test), ale může se zlepšit výkon testů. Před Vitest 0.29.0 to bylo ekvivalentní použití --no-threads.

WARNING

I když tato možnost vynutí spouštění testů jeden po druhém, liší se od Jest's --runInBand. Vitest používá workery nejen pro paralelní spouštění testů, ale také k zajištění izolace. Zakázáním této možnosti se vaše testy spustí sekvenčně, ale ve stejném globálním kontextu, takže izolaci musíte zajistit sami.

To může způsobit problémy, pokud se spoléháte na globální stav (frontendové frameworky to obvykle dělají) nebo váš kód spoléhá na to, že prostředí bude definováno samostatně pro každý test. Může to vést ke zrychlení vašich testů (až 3krát rychlejší), které se nutně nespoléhají na globální stav nebo to mohou snadno obejít.

maxThreads*

Typ: number
Výchozí: dostupné CPU

Maximální počet threadů. Můžete také použít proměnnou prostředí VITEST_MAX_THREADS.

minThreads*

Typ: number
Výchozí: dostupné CPU

Minimální počet threadů. Můžete také použít proměnnou prostředí VITEST_MIN_THREADS.

useAtomics*

Typ: boolean
Výchozí: false
Verze: Od Vitest 0.28.3

Používá Atomics k synchronizaci threadů.

To může v některých případech zlepšit výkon, ale může způsobit segfault ve starších verzích Node.

testTimeout

Typ: number
Výchozí: 5000
CLI: --test-timeout=5000

Výchozí timeout testu v milisekundách.

hookTimeout

Typ: number
Výchozí: 10000

Výchozí timeout hooku v milisekundách.

teardownTimeout*

Typ: number
Výchozí: 10000

Výchozí timeout pro čekání na ukončení, když se Vitest vypíná, v milisekundách.

silent*

Typ: boolean
Výchozí: false
CLI: --silent, --silent=false

Potlačí výstup konzole z testů.

setupFiles

Typ: string | string[]

Cesta k souborům nastavení (setup files). Tyto soubory budou spuštěny před každým testovacím souborem.

INFO

Změna souborů nastavení způsobí opětovné spuštění všech testů.

Uvnitř můžete použít process.env.VITEST_POOL_ID (celočíselný řetězec) k rozlišení mezi thready (bude vždy '1', pokud je spuštěn s threads: false).

TIP

Upozorňujeme, že při spuštění s --threads=false bude tento soubor setupu spuštěn ve stejném globálním rozsahu vícekrát. To znamená, že vždy pracujete se stejným globálním objektem před každým testem, takže se ujistěte, že neděláte totéž více, než je nutné.

Můžete se například spolehnout na globální proměnnou:

import { config } from '@some-testing-lib';

if (!globalThis.defined) {
  config.plugins = [myCoolPlugin];
  computeHeavyThing();
  globalThis.defined = true;
}

// hooks are reset before each suite
afterEach(() => {
  cleanup();
});

globalThis.resetBeforeEachTest = true;

globalSetup

Typ: string | string[]

Cesta ke globálním souborům nastavení, relativní ke kořeni projektu.

Globální soubor nastavení může exportovat buď pojmenované funkce setup a teardown, nebo výchozí funkci, která vrací funkci teardown (příklad).

INFO

Je možné použít více globálních souborů nastavení. Funkce setup a teardown jsou spouštěny sekvenčně s funkcí teardown v opačném pořadí.

WARNING

Uvědomte si, že globální setup je spuštěn v jiném globálním rozsahu, takže vaše testy nemají přístup k proměnným zde definovaným.

watchExclude*

Typ: string[]
Výchozí: ['**/node_modules/**', '**/dist/**']

Vzorec glob pro cesty k souborům, které mají být ignorovány, aby nespustily opakované spuštění sledování.

forceRerunTriggers*

Typ: string[]
Výchozí: ['**/package.json/**', '**/vitest.config.*/**', '**/vite.config.*/**']

Vzorec glob pro cesty k souborům, které spustí opakované spuštění celé sady. V kombinaci s argumentem --changed spustí celou testovací sadu, pokud je spouštěč nalezen v git diff.

Užitečné, pokud testujete volání příkazů CLI, protože Vite nemůže vytvořit graf modulů:

test('execute a script', async () => {
  // Vitest cannot rerun this test, if content of `dist/index.js` changes
  await execa('node', ['dist/index.js']);
});

TIP

Ujistěte se, že vaše soubory nejsou vyloučeny pomocí watchExclude.

isolate

Typ: boolean
Výchozí: true
CLI: --isolate, --isolate=false

Izoluje prostředí pro každý testovací soubor. Tato volba nemá žádný efekt, pokud je zakázáno --threads.

Tato možnost nemá žádný vliv na experimentalVmThreads.

coverage*

Pro sběr pokrytí můžete použít v8, istanbul nebo vlastní řešení pokrytí.

Možnosti pokrytí můžete zadat v CLI pomocí tečkové notace:

npx vitest --coverage.enabled --coverage.provider=istanbul --coverage.all

WARNING

Pokud používáte možnosti pokrytí s tečkovou notací, ujistěte se, že uvádíte --coverage.enabled. V takovém případě nezadávejte pouze --coverage.

coverage.provider

Typ: 'v8' | 'istanbul' | 'custom'
Výchozí: 'v8'
CLI: --coverage.provider=<provider>

Použijte provider k výběru nástroje pro sběr pokrytí.

coverage.enabled

Typ: boolean
Výchozí: false
Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.enabled, --coverage.enabled=false

Povolí sběr pokrytí. Lze přepsat pomocí volby CLI --coverage.

coverage.include

Typ: string[]
Výchozí: ['**']
Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.include=<path>, --coverage.include=<path1> --coverage.include=<path2>

Seznam souborů, které se mají zahrnout do pokrytí, pomocí glob vzorů.

coverage.extension

Typ: string | string[]
Výchozí: ['.js', '.cjs', '.mjs', '.ts', '.mts', '.cts', '.tsx', '.jsx', '.vue', '.svelte']
Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.extension=<extension>, --coverage.extension=<extension1> --coverage.extension=<extension2>

coverage.exclude

Typ: string[]
Výchozí:

[
  'coverage/**',
  'dist/**',
  'packages/*/test?(s)/**',
  '**/*.d.ts',
  '**/virtual:*',
  '**/__x00__*',
  '**/\x00*',
  'cypress/**',
  'test?(s)/**',
  'test?(-*).?(c|m)[jt]s?(x)',
  '**/*{.,-}{test,spec}.?(c|m)[jt]s?(x)',
  '**/__tests__/**',
  '**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build}.config.*',
  '**/vitest.{workspace,projects}.[jt]s?(on)',
  '**/.{eslint,mocha,prettier}rc.{?(c|m)js,yml}',
];

Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.exclude=<path>, --coverage.exclude=<path1> --coverage.exclude=<path2>

Seznam souborů, které se mají vyloučit z pokrytí, jako glob vzory.

coverage.all

Typ: boolean
Výchozí: false
Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.all, --coverage.all=false

Určuje, zda se mají do zprávy zahrnout všechny soubory, včetně těch, které nejsou testovány.

coverage.clean

Typ: boolean
Výchozí: true
Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.clean, --coverage.clean=false

Vymaže výsledky pokrytí před spuštěním testů.

coverage.cleanOnRerun

Typ: boolean
Výchozí: true
Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.cleanOnRerun, --coverage.cleanOnRerun=false

Vymaže zprávu o pokrytí při opakovaném spuštění v režimu sledování.

coverage.reportsDirectory

Typ: string
Výchozí: './coverage'
Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.reportsDirectory=<path>

Adresář, do kterého se zapisují zprávy o pokrytí.

coverage.reporter

Typ: string | string[] | [string, {}][]
Výchozí: ['text', 'html', 'clover', 'json']
Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.reporter=<reporter>, --coverage.reporter=<reporter1> --coverage.reporter=<reporter2>

Reportéry pokrytí, které se mají použít. Podrobný seznam všech reportérů naleznete v dokumentaci istanbul. Podrobnosti o možnostech specifických pro reportéry naleznete v @types/istanbul-reporter.

Reportér má tři různé typy:

Jeden reportér: { reporter: 'html' }
Více reportérů bez možností: { reporter: ['html', 'json'] }

Jeden nebo více reportérů s možnostmi:

{
  reporter: [
    ['lcov', { projectRoot: './src' }],
    ['json', { file: 'coverage.json' }],
    ['text'],
  ];
}

Od verze Vitest 0.31.0 můžete zkontrolovat zprávu o pokrytí v uživatelském rozhraní Vitest: podívejte se na Vitest UI Coverage pro více podrobností.

coverage.reportOnFailure

Typ: boolean
Výchozí: false (od Vitest 0.34.0)
Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.reportOnFailure, --coverage.reportOnFailure=false
Verze: Od Vitest 0.31.2

Generuje zprávu o pokrytí, i když testy selžou.

coverage.allowExternal

Typ: boolean
Výchozí: false
Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.allowExternal, --coverage.allowExternal=false

Sbírá pokrytí souborů mimo kořenový adresář projektu.

coverage.skipFull

Typ: boolean
Výchozí: false
Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.skipFull, --coverage.skipFull=false

Nezobrazuje soubory se 100% pokrytím příkazů, větví a funkcí.

coverage.perFile

Typ: boolean
Výchozí: false
Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.perFile, --coverage.perFile=false

Kontroluje prahové hodnoty pro jednotlivé soubory. Skutečné prahové hodnoty naleznete v lines, functions, branches a statements.

coverage.thresholdAutoUpdate

Typ: boolean
Výchozí: false
Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.thresholdAutoUpdate=<boolean>

Aktualizuje prahové hodnoty lines, functions, branches a statements v konfiguračním souboru, pokud je aktuální pokrytí nad nastavenými prahovými hodnotami. Tato možnost pomáhá udržovat prahové hodnoty, když se pokrytí zlepší.

coverage.lines

Typ: number
Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.lines=<number>

Prahová hodnota pro řádky. Více informací naleznete v dokumentaci istanbul.

coverage.functions

Typ: number
Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.functions=<number>

Prahová hodnota pro funkce. Více informací naleznete v dokumentaci istanbul.

coverage.branches

Typ: number
Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.branches=<number>

Prahová hodnota pro větve. Více informací naleznete v dokumentaci istanbul.

coverage.statements

Typ: number
Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.statements=<number>

Prahová hodnota pro příkazy. Více informací naleznete v dokumentaci istanbul.

coverage.100

Typ: boolean
Výchozí: false
Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.100, --coverage.100=false

Zkratka pro --coverage.lines 100 --coverage.functions 100 --coverage.branches 100 --coverage.statements 100.

coverage.ignoreClassMethods

Typ: string[]
Výchozí: []
Dostupné pro poskytovatele: 'istanbul'
CLI: --coverage.ignoreClassMethods=<method>

Nastavte na pole názvů metod třídy, které se mají ignorovat při pokrytí. Více informací naleznete v dokumentaci istanbul.

coverage.watermarks

Typ:

{
  statements?: [number, number],
  functions?: [number, number],
  branches?: [number, number],
  lines?: [number, number]
}

Výchozí:

{
  statements: [50, 80],
  functions: [50, 80],
  branches: [50, 80],
  lines: [50, 80]
}

Dostupné pro poskytovatele: 'v8' | 'istanbul'

Vodoznaky pro příkazy, řádky, větve a funkce. Více informací naleznete v dokumentaci istanbul.

coverage.customProviderModule

Typ: string
Dostupné pro poskytovatele: 'custom'
CLI: --coverage.customProviderModule=<path or module name>

Určuje název modulu nebo cestu k modulu vlastního poskytovatele pokrytí. Více informací naleznete v Průvodci - Vlastní poskytovatel pokrytí.

testNamePattern*

Typ: string | RegExp
CLI: -t <pattern>, --testNamePattern=<pattern>, --test-name-pattern=<pattern>

Spouští testy, jejichž plné názvy odpovídají vzoru. Pokud přidáte OnlyRunThis do této vlastnosti, testy, které neobsahují slovo OnlyRunThis v názvu, budou přeskočeny.

import { expect, test } from 'vitest';

// run
test('OnlyRunThis', () => {
  expect(true).toBe(true);
});

// skipped
test('doNotRun', () => {
  expect(true).toBe(true);
});

open*

Typ: boolean
Výchozí: false
CLI: --open, --open=false

Otevře Vitest UI (WIP)

api

Typ: boolean | number
Výchozí: false
CLI: --api, --api.port, --api.host, --api.strictPort

Poslouchá na portu a obsluhuje API. Pokud je nastaveno na true, výchozí port je 51204.

browser

Typ: { enabled?, name?, provider?, headless?, api?, slowHijackESM? }
Výchozí: { enabled: false, headless: process.env.CI, api: 63315 }
Verze: Od Vitest 0.29.4
CLI: --browser, --browser=<name>, --browser.name=chrome --browser.headless

Spouští testy Vitest v prohlížeči. Pro spouštění testů ve výchozím nastavení používáme WebdriverIO, ale lze jej nakonfigurovat pomocí možnosti browser.provider.

NOTE

Přečtěte si více o testování v reálném prohlížeči na stránce průvodce.

WARNING

Toto je experimentální funkce. Zásadní změny nemusí dodržovat semver, při používání si prosím připněte verzi Vitest.

browser.enabled

Typ: boolean
Výchozí: false
CLI: --browser, --browser.enabled=false

Ve výchozím nastavení spouští všechny testy uvnitř prohlížeče. Lze přepsat pomocí možnosti poolMatchGlobs.

browser.name

Typ: string
CLI: --browser=safari

Spouští všechny testy v konkrétním prohlížeči. Možné hodnoty u různých poskytovatelů:

webdriverio: firefox, chrome, edge, safari
playwright: firefox, webkit, chromium
custom: jakýkoli řetězec, který bude předán poskytovateli

browser.headless

Typ: boolean
Výchozí: process.env.CI
CLI: --browser.headless, --brower.headless=false

Spouští prohlížeč v režimu bez grafického rozhraní. Pokud spouštíte Vitest v CI (Continuous Integration), bude ve výchozím nastavení povoleno.

browser.api

Typ: number | { port?, strictPort?, host? }
Výchozí: 63315
CLI: --browser.api=63315, --browser.api.port=1234, --browser.api.host=example.com

Konfiguruje možnosti pro server Vite, který obsluhuje kód v prohlížeči. Nemá vliv na možnost test.api.

browser.provider

Typ: 'webdriverio' | 'playwright' | string
Výchozí: 'webdriverio'
CLI: --browser.provider=playwright

Cesta k poskytovateli, který bude použit při spouštění testů v prohlížeči. Vitest poskytuje dva poskytovatele, kterými jsou webdriverio (výchozí) a playwright. Vlastní poskytovatelé by měli být exportováni pomocí default exportu a mít tento tvar:

export interface BrowserProvider {
  name: string;
  getSupportedBrowsers(): readonly string[];
  initialize(ctx: Vitest, options: { browser: string }): Awaitable<void>;
  openPage(url: string): Awaitable<void>;
  close(): Awaitable<void>;
}

WARNING

Toto je pokročilé API pro tvůrce knihoven. Pokud potřebujete pouze spouštět testy v prohlížeči, použijte možnost browser.

browser.slowHijackESM

Typ: boolean
Výchozí: true
Verze: Od Vitest 0.31.0

Při provádění testů v Node.js může Vitest používat vlastní řešení pro práci s moduly, které usnadňuje mockování modulů pomocí syntaxe vi.mock. Nicméně, replikace chování ES modulů v prohlížeči není tak jednoduchá, a proto je nutné transformovat zdrojové soubory předtím, než je prohlížeč může použít.

Tato volba nemá žádný vliv na testy spouštěné v Node.js.

Ve výchozím stavu je tato možnost aktivní při spuštění v prohlížeči. Pokud nevyužíváte špehování ES modulů pomocí vi.spyOn a nepoužíváte vi.mock, můžete ji zakázat pro mírné zvýšení výkonu.

clearMocks

Typ: boolean
Výchozí: false

Zavolá .mockClear() na všechny spy objekty před každým testem. Tím se vymaže historie volání mocků, ale implementace zůstane nezměněna.

mockReset

Typ: boolean
Výchozí: false

Zavolá .mockReset() na všechny spy objekty před každým testem. Tím se vymaže historie volání mocků a implementace se resetuje na prázdnou funkci, která vrací undefined.

restoreMocks

Typ: boolean
Výchozí: false

Zavolá .mockRestore() na všechny spy objekty před každým testem. Tím se vymaže historie volání mocků a implementace se obnoví do původního stavu.

unstubEnvs

Typ: boolean
Výchozí: false
Verze: Od Vitest 0.26.0

Před každým testem zavolá vi.unstubAllEnvs.

unstubGlobals

Typ: boolean
Výchozí: false
Verze: Od Vitest 0.26.0

Před každým testem zavolá vi.unstubAllGlobals.

testTransformMode

Typ: { web?, ssr? }
Verze: Od Vitest 0.34.0

Určuje, jak se mají transformovat moduly importované v testech, které odpovídají danému glob vzoru. Standardně se chování řídí prostředím. Například testy s prostředím JSDOM zpracovávají všechny soubory s příznakem ssr: false, zatímco testy s prostředím Node zpracovávají všechny moduly s ssr: true.

testTransformMode.ssr

Typ: string[]
Výchozí: []

Použije SSR transformaci pro všechny moduly ve specifikovaných testech.
Vite pluginy obdrží příznak ssr: true při zpracování těchto souborů.

testTransformMode.web

Typ: string[]
Výchozí: []

Provede běžnou transformaci (cílenou na prohlížeč) a poté provede SSR přepis pro spuštění kódu v Node.
Vite pluginy obdrží příznak ssr: false při zpracování těchto souborů.

snapshotFormat*

Typ: PrettyFormatOptions

Možnosti formátování pro snapshot testing. Tyto možnosti jsou předávány do pretty-format.

resolveSnapshotPath*

Typ: (testPath: string, snapExtension: string) => string
Výchozí: ukládá snapshot soubory do adresáře __snapshots__

Přepisuje výchozí cestu pro snapshoty. Například pro uložení snapshotů vedle testovacích souborů použijte:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    resolveSnapshotPath: (testPath, snapExtension) => testPath + snapExtension,
  },
});

allowOnly

Typ: boolean
Výchozí: false
CLI: --allowOnly, --allowOnly=false

Povoluje spouštění pouze testů a sad označených jako 'only'.

dangerouslyIgnoreUnhandledErrors*

Typ: boolean
Výchozí: false
CLI: --dangerouslyIgnoreUnhandledErrors --dangerouslyIgnoreUnhandledErrors=false

Ignoruje všechny nezachycené chyby, které se vyskytnou. Používejte s opatrností!

passWithNoTests*

Typ: boolean
Výchozí: false
CLI: --passWithNoTests, --passWithNoTests=false

Vitest nebude považovat za chybu, pokud nebudou nalezeny žádné testy.

logHeapUsage

Typ: boolean
Výchozí: false
CLI: --logHeapUsage, --logHeapUsage=false

Zobrazí využití paměti po každém testu. Užitečné pro ladění úniků paměti.

css

Typ: boolean | { include?, exclude?, modules? }

Konfiguruje, zda se má CSS zpracovávat. Pokud jsou vyloučeny, CSS soubory budou nahrazeny prázdnými řetězci, čímž se přeskočí jejich další zpracování. CSS Modules vrátí proxy, aby neovlivnily běh aplikace.

css.include

Typ: RegExp | RegExp[]
Výchozí: []

Regulární výraz pro soubory, které by měly vracet skutečné CSS a budou zpracovány pomocí Vite pipeline.

TIP

Pro zpracování všech CSS souborů použijte /.+/.

css.exclude

Typ: RegExp | RegExp[]
Výchozí: []

Regulární výraz pro soubory, které vrátí prázdný CSS soubor.

css.modules

Typ: { classNameStrategy? }
Výchozí: {}

css.modules.classNameStrategy

Typ: 'stable' | 'scoped' | 'non-scoped'
Výchozí: 'stable'

Pokud povolíte zpracování CSS souborů, můžete nastavit, zda se mají názvy tříd v CSS modulech omezit na daný rozsah (scope). Můžete si vybrat jednu z možností:

stable: názvy tříd budou generovány jako _${name}_${hashedFilename}, což znamená, že generovaná třída zůstane stejná, pokud se změní obsah CSS, ale změní se, pokud se změní název souboru, nebo se soubor přesune do jiné složky. Toto nastavení je užitečné, pokud využíváte funkci snapshot.
scoped: názvy tříd budou generovány jako obvykle, s ohledem na metodu css.modules.generateScopeName, pokud ji máte a zpracování CSS je povoleno. Ve výchozím nastavení bude název souboru generován jako _${name}_${hash}, kde hash zahrnuje název souboru a obsah souboru.
non-scoped: názvy tříd nebudou hashovány.

WARNING

Ve výchozím nastavení Vitest exportuje proxy, která obchází zpracování CSS Modules. Pokud se spoléháte na CSS vlastnosti ve svých třídách, musíte povolit zpracování CSS pomocí volby include.

maxConcurrency

Typ: number
Výchozí: 5

Maximální počet testů, které mohou být spuštěny současně, označených jako test.concurrent.

Testy přesahující tento limit budou zařazeny do fronty a spuštěny, jakmile se uvolní místo.

cache*

Typ: false | { dir? }

Možnosti pro konfiguraci chování cache ve Vitest. V současné době Vitest ukládá do cache výsledky testů, aby se nejprve spustily delší a neúspěšné testy.

cache.dir

Typ: string
Výchozí: node_modules/.vitest

Cesta k adresáři pro cache.

sequence

Typ: { sequencer?, shuffle?, seed?, hooks?, setupFiles? }

Možnosti pro určení pořadí, v jakém by měly být testy spouštěny.

Můžete předat možnosti sekvence do CLI pomocí tečkové notace:

npx vitest --sequence.shuffle --sequence.seed=1000

sequence.sequencer*

Typ: TestSequencerConstructor
Výchozí: BaseSequencer

Vlastní třída, která definuje metody pro shardování a řazení testů. Můžete rozšířit BaseSequencer z vitest/node, pokud potřebujete pouze redefinovat jednu z metod sort a shard, ale obě by měly existovat.

Shardování probíhá před řazením a pouze pokud je zadána volba --shard.

sequence.shuffle

Typ: boolean
Výchozí: false
CLI: --sequence.shuffle, --sequence.shuffle=false

Pokud si přejete spouštět testy v náhodném pořadí, povolte tuto možnost nebo použijte argument příkazové řádky --sequence.shuffle.

Vitest obvykle používá cache pro řazení testů, takže dlouho běžící testy začínají dříve - to urychluje provádění testů. Pokud se vaše testy spouštějí v náhodném pořadí, ztratíte toto zlepšení výkonu, ale může být užitečné sledovat testy, které náhodou závisí na předchozím spuštění.

sequence.concurrent

Typ: boolean
Výchozí: false
CLI: --sequence.concurrent, --sequence.concurrent=false
Verze: Od Vitest 0.32.2

Pokud si přejete spouštět testy paralelně, povolte tuto možnost nebo použijte argument příkazové řádky --sequence.concurrent.

sequence.seed*

Typ: number
Výchozí: Date.now()
CLI: --sequence.seed=1000

Nastaví seed pro náhodné řazení, pokud se testy spouštějí v náhodném pořadí.

sequence.hooks

Typ: 'stack' | 'list' | 'parallel'
Výchozí: 'parallel'
CLI: --sequence.hooks=<value>

Změní pořadí, v jakém se spouštějí hooky.

stack seřadí "after" hooky v opačném pořadí, "before" hooky se spustí v pořadí, v jakém byly definovány
list seřadí všechny hooky v pořadí, v jakém jsou definovány
parallel spustí hooky v jedné skupině paralelně (hooky v nadřazených sadách se stále spustí před hooky aktuální sady)

sequence.setupFiles

Typ: 'list' | 'parallel'
Výchozí: 'parallel'
CLI: --sequence.setupFiles=<value>
Verze: Od Vitest 0.29.3

Změní pořadí, v jakém se spouštějí setup soubory.

list spustí setup soubory v pořadí, v jakém jsou definovány
parallel spustí setup soubory paralelně

typecheck

Možnosti pro konfiguraci testovacího prostředí pro kontrolu typů.

typecheck.checker

Typ: 'tsc' | 'vue-tsc' | string
Výchozí: tsc

Určuje, jaký nástroj se má použít pro kontrolu typů. Vitest spustí proces s parametry, které usnadňují parsování, v závislosti na zvoleném nástroji. Checker by měl implementovat stejný formát výstupu jako tsc.

Pro použití typecheckeru je nutné mít nainstalovaný následující balíček:

tsc vyžaduje balíček typescript
vue-tsc vyžaduje balíček vue-tsc

Můžete také předat cestu k vlastní binárce nebo název příkazu, který produkuje stejný výstup jako tsc --noEmit --pretty false.

typecheck.include

Typ: string[]
Výchozí: ['**/*.{test,spec}-d.?(c|m)[jt]s?(x)']

Globální maska pro soubory, které by měly být považovány za testovací soubory.

typecheck.exclude

Typ: string[]
Výchozí: ['**/node_modules/**', '**/dist/**', '**/cypress/**', '**/.{idea,git,cache,output,temp}/**']

Globální maska pro soubory, které by neměly být považovány za testovací soubory.

typecheck.allowJs

Typ: boolean
Výchozí: false

Zkontroluje JS soubory, které obsahují komentář @ts-check. Pokud to máte povoleno v tsconfig, toto to nepřepíše.

typecheck.ignoreSourceErrors

Typ: boolean
Výchozí: false

Nezpůsobí selhání testů, pokud Vitest nalezne chyby mimo testovací soubory. Nebudou se zobrazovat chyby mimo testovací soubory.

Ve výchozím nastavení, pokud Vitest najde chybu ve zdrojovém kódu, selže testovací sada.

typecheck.tsconfig

Typ: string
Výchozí: pokusí se najít nejbližší tsconfig.json

Cesta k vlastnímu souboru tsconfig, relativní ke kořeni projektu.

slowTestThreshold*

Typ: number
Výchozí: 300

Počet milisekund, po kterých je test považován za pomalý a je takto hlášen ve výsledcích.

chaiConfig

Typ: { includeStack?, showDiff?, truncateThreshold? }
Výchozí: { includeStack: false, showDiff: true, truncateThreshold: 40 }
Verze: Od Vitest 0.30.0

Konfigurace pro Chai assertion library.

chaiConfig.includeStack

Typ: boolean
Výchozí: false

Určuje, zda je stopa zásobníku zahrnuta v chybové zprávě assertion. Výchozí hodnota false potlačuje stopu zásobníku v chybové zprávě.

chaiConfig.showDiff

Typ: boolean
Výchozí: true

Určuje, zda má být příznak showDiff zahrnut v vyvolaných AssertionError. false bude vždy false; true bude true, když assertion požaduje zobrazení diff.

chaiConfig.truncateThreshold

Typ: number
Výchozí: 40

Nastavuje prahovou délku pro skutečné a očekávané hodnoty v chybových hlášeních. Pokud je tento práh překročen, například pro velké datové struktury, je hodnota nahrazena něčím jako [ Array(3) ] nebo { Object (prop1, prop2) }. Nastavte ji na 0, pokud chcete úplně zakázat zkracování.

Tato konfigurační volba ovlivňuje zkracování hodnot v titulcích test.each a v chybových hlášeních.

bail

Typ: number
Výchozí: 0
CLI: --bail=<value>
Verze: Od Vitest 0.31.0

Zastaví provádění testů, pokud selže daný počet testů.

To může být užitečné v CI/CD, kde je cílem dosáhnout pouze 100% úspěšných buildů a je potřeba zastavit provádění testů co nejdříve po selhání. Volba bail může být použita k urychlení CI běhů tím, že zabrání spuštění dalších testů, pokud dojde k selhání.

retry

Typ: number
Výchozí: 0
CLI: --retry=<value>
Verze: Od Vitest 0.32.3

Opakuje test daný počet krát, pokud selže.

onConsoleLog

Typ: (log: string, type: 'stdout' | 'stderr') => false | void

Vlastní obsluha pro console.log v testech. Pokud vrátíte false, Vitest nevytiskne log do konzole.

Může být užitečné pro filtrování logů z externích knihoven.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    onConsoleLog(log: string, type: 'stdout' | 'stderr'): boolean | void {
      if (log === 'message from third party library' && type === 'stdout')
        return false;
    },
  },
});

diff

Typ: string
CLI: --diff=<value>
Verze: Od Vitest 0.34.5

Cesta ke konfiguračnímu souboru, který se použije pro generování rozhraní pro porovnávání (diff). Užitečné, pokud chcete přizpůsobit zobrazení diffu.

vitest.diff.tsvitest.config.js

import type { DiffOptions } from 'vitest';
import c from 'picocolors';

export default {
  aIndicator: c.bold('--'),
  bIndicator: c.bold('++'),
  omitAnnotationLines: true,
} satisfies DiffOptions;

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    diff: './vitest.diff.ts',
  },
});

Konfigurace Vitest ​

Konfigurace ​

Možnosti ​

include ​

exclude ​

includeSource ​

server ​

server.sourcemap ​

server.debug ​

server.debug.dumpModules ​

server.debug.loadDumppedModules ​

server.deps ​

server.deps.external ​

server.deps.inline ​

server.deps.fallbackCJS ​

server.deps.cacheDir ​

deps ​

deps.optimizer ​

deps.optimizer.{mode}.enabled ​

deps.web ​

deps.web.transformAssets ​

deps.web.transformCss ​

deps.web.transformGlobPattern ​

deps.registerNodeLoader* ​

deps.interopDefault ​

deps.moduleDirectories ​

runner ​

benchmark ​

benchmark.include ​

benchmark.exclude ​

benchmark.includeSource ​

benchmark.reporters ​

benchmark.outputFile ​

alias ​

globals ​

environment ​

environmentOptions ​

environmentMatchGlobs ​

poolMatchGlobs ​

update* ​

watch* ​

root ​

reporters* ​

outputFile* ​

experimentalVmThreads ​

experimentalVmWorkerMemoryLimit ​

threads ​

singleThread ​

maxThreads* ​

minThreads* ​

useAtomics* ​

testTimeout ​

hookTimeout ​

teardownTimeout* ​

silent* ​

setupFiles ​

globalSetup ​

watchExclude* ​

forceRerunTriggers* ​

isolate ​

coverage* ​

coverage.provider ​

coverage.enabled ​

coverage.include ​

coverage.extension ​

coverage.exclude ​

coverage.all ​

coverage.clean ​

coverage.cleanOnRerun ​

coverage.reportsDirectory ​

coverage.reporter ​

coverage.reportOnFailure ​

coverage.allowExternal ​

coverage.skipFull ​

coverage.perFile ​

coverage.thresholdAutoUpdate ​

coverage.lines ​

coverage.functions ​

coverage.branches ​

coverage.statements ​

Konfigurace Vitest

Konfigurace

Možnosti

include

exclude

includeSource

server

server.sourcemap

server.debug

server.debug.dumpModules

server.debug.loadDumppedModules

server.deps

server.deps.external

server.deps.inline

server.deps.fallbackCJS

server.deps.cacheDir

deps

deps.optimizer

deps.optimizer.{mode}.enabled

deps.web

deps.web.transformAssets

deps.web.transformCss

deps.web.transformGlobPattern

deps.registerNodeLoader*

deps.interopDefault

deps.moduleDirectories

runner

benchmark

benchmark.include

benchmark.exclude

benchmark.includeSource

benchmark.reporters

benchmark.outputFile

alias

globals

environment

environmentOptions

environmentMatchGlobs

poolMatchGlobs

update*

watch*

root

reporters*

outputFile*

experimentalVmThreads

experimentalVmWorkerMemoryLimit

threads

singleThread

maxThreads*

minThreads*

useAtomics*

testTimeout

hookTimeout

teardownTimeout*

silent*

setupFiles

globalSetup

watchExclude*

forceRerunTriggers*

isolate

coverage*

coverage.provider

coverage.enabled

coverage.include

coverage.extension

coverage.exclude

coverage.all

coverage.clean

coverage.cleanOnRerun

coverage.reportsDirectory

coverage.reporter

coverage.reportOnFailure

coverage.allowExternal

coverage.skipFull

coverage.perFile

coverage.thresholdAutoUpdate

coverage.lines

coverage.functions

coverage.branches

coverage.statements