Konfigurace Vitest

Pro vytvoření konfiguračního souboru Vitest se řiďte návodem. Než budete pokračovat, ujistěte se, že rozumíte, jak Vitest zpracovává konfiguraci.

WARNING

Všechny zde uvedené možnosti se nacházejí ve vlastnosti test uvnitř konfigurace:

export default defineConfig({
  test: {
    exclude: [],
  },
});

TIP

Kromě následujících možností můžete také použít jakoukoli konfigurační možnost z Vite. Například define pro definování globálních proměnných nebo resolve.alias pro definování aliasů cest.

Všechny konfigurační možnosti, které nejsou podporovány v konfiguraci pracovního prostoru, mají vedle sebe označení *.

include

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

Seznam glob vzorů, které odpovídají souborům s testy.

POZNÁMKA

Při použití pokrytí Vitest automaticky přidá vzory include testovacích souborů do výchozích vzorů exclude pokrytí. Viz coverage.exclude.

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.*']
CLI: vitest --exclude "**/excluded-file"

Seznam glob vzorů, které by měly být vyloučeny z testování.

WARNING

Tato možnost nemá vliv na pokrytí kódu (coverage). Pokud potřebujete odstranit určité soubory z reportu pokrytí, použijte coverage.exclude.

Toto je jediná možnost, která nepřepíše vaši konfiguraci, pokud je zadána pomocí příznaku CLI. Všechny glob vzory přidané pomocí příznaku --exclude budou přidány do pole exclude v konfiguraci.

includeSource

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

Zahrnuje glob vzory pro testovací soubory ve zdrojovém kódu.

Pokud je definováno, Vitest spustí všechny odpovídající soubory, které obsahují import.meta.vitest.

server

Typ: { sourcemap?, deps?, ... }

Možnosti serveru Vite-Node.

server.sourcemap

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

Vkládá inline source mapy do modulů.

server.debug

Typ: { dumpModules?, loadDumppedModules? }

Možnosti ladění Vite-Node.

server.debug.dumpModules

Typ: boolean | string

Uloží transformovaný modul do souborového systému. Pokud je zadán řetězec, uloží modul do zadané cesty.

server.debug.loadDumppedModules

Typ: boolean

Načte uložený modul ze souborového systému, pokud je k dispozici. Užitečné pro ladění úpravou výsledku uloženého modulu v souborovém systému.

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ředá balíček nativnímu Node.js. Externalizované závislosti nebudou transformovány pomocí transformátorů a překladačů Vite, takže nepodporují HMR při opětovném načtení. Ve výchozím nastavení jsou všechny balíčky uvnitř node_modules externalizovány.

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

Pokud je použit 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 bude zpracovávat vložené moduly. To může být užitečné při práci s balíčky, které poskytují .js v ESM formátu (který Node neumí zpracovat).

Pokud je 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

Když je závislost platný balíček ESM, pokusí se Vitest odhadnout verzi CJS na základě 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?, ... }

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

deps.optimizer

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

Umožňuje optimalizaci závislostí. Pokud máte hodně testů, může to zlepšit jejich výkon.

Pokud Vitest narazí na externí knihovnu uvedenou v include, bude tato knihovna zabalena do jednoho souboru pomocí esbuild a importována jako jeden modul. To je dobré z několika důvodů:

Import balíčků s velkým množstvím importů je nákladný. Seskupením do jednoho souboru můžeme ušetřit spoustu času.
Import knihoven UI je nákladný, protože nejsou primárně určeny ke spuštění v Node.js.
Vaše konfigurace alias je nyní respektována i uvnitř svázaných balíčků.
Kód ve vašich testech se spouští podobně, jako by se spouštěl 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 informací o dostupných možnostech naleznete v dokumentaci Vite. Vitest nepodporuje možnosti disable a noDiscovery. Ve výchozím nastavení Vitest používá optimizer.web pro prostředí jsdom a happy-dom a optimizer.ssr pro prostředí node a edge, ale je to 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žnosti include/exclude v deps.optimizer, rozšíří se o ně vaše optimizeDeps při spouštění testů. Vitest automaticky odebere stejné možnosti z include, pokud jsou také uvedeny v exclude.

TIP

Nebudete moci upravovat kód v node_modules pro ladění, protože se 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í: false

Povolí optimalizaci závislostí.

deps.web

Typ: { transformAssets?, ... }

Možnosti, které se aplikují na externí soubory, pokud je režim transformace nastaven na web. Ve výchozím nastavení jsdom a happy-dom používají režim web, zatímco prostředí node a edge používají režim transformace ssr, takže tyto možnosti nebudou mít 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 rovnající se cestě k aktivu, pokud není zadán žádný dotaz.

WARNING

V současné době tato možnost funguje pouze s fondy vmThreads a vmForks.

deps.web.transformCss

Typ: boolean
Výchozí: true

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

Pokud jsou soubory CSS zakázány pomocí možností css, tato možnost pouze zamezí chybám ERR_UNKNOWN_FILE_EXTENSION.

WARNING

V současné době tato možnost funguje pouze s fondy vmThreads a vmForks.

deps.web.transformGlobPattern

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

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

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

WARNING

V současné době tato možnost funguje pouze s fondy vmThreads a vmForks.

deps.interopDefault

Typ: boolean
Výchozí: true

Interpretuje výchozí export modulu CJS jako pojmenované exporty. Některé závislosti obsahují pouze moduly CJS a nepoužívají pojmenované exporty, které Node.js dokáže staticky analyzovat, pokud je balíček importován pomocí syntaxe import místo require. Při importu takových závislostí v prostředí Node 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. Pokud je tato funkce zakázána, s největší pravděpodobností se tato chyba zobrazí při spouštění testů:

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

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

deps.moduleDirectories

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

Seznam adresářů, které by měly být považovány za adresáře modulů. Tato konfigurační možnost ovlivňuje chování vi.mock: pokud není poskytnuta žádná továrna a cesta k parodovanému modulu odpovídá jedné z hodnot moduleDirectories, Vitest se pokusí najít mock hledáním složky __mocks__ v kořeni 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, zahrňte tento adresář spolu s dalšími možnostmi:

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ímu spouštěči testů. Jedná se o pokročilou funkci, která by měla 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 spouštění vitest bench.

benchmark.include

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

Zahrnuje glob vzory pro soubory benchmark testů.

benchmark.exclude

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

Vylučuje glob vzory pro soubory benchmark testů.

benchmark.includeSource

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

Zahrnuje glob vzory pro soubory benchmark testů ve zdrojovém kódu. Tato možnost je podobná includeSource.

Pokud je definováno, Vitest spustí všechny odpovídající soubory, které obsahují import.meta.vitest.

benchmark.reporters

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

Vlastní reporter pro výstup. Může obsahovat jeden nebo více vestavěných názvů reportů, instancí reporterů nebo cest k vlastním reporterům.

benchmark.outputFile

Zastaralé, nahrazeno benchmark.outputJson.

benchmark.outputJson

Typ: string | undefined
Výchozí: undefined

Cesta k souboru pro uložení výsledku benchmarku, který lze později využít pro porovnání pomocí --compare.

Například:

# uložení výsledku hlavní větve
git checkout main
vitest bench --outputJson main.json

# změna větve a porovnání s hlavní větví
git checkout feature
vitest bench --compare main.json

benchmark.compare

Typ: string | undefined
Výchozí: undefined

Cesta k souboru s předchozím výsledkem benchmarku pro porovnání s aktuálními spuštěními.

alias

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

Definuje vlastní aliasy při spouštění testů. Tyto aliasy budou sloučeny s aliasy z resolve.alias.

WARNING

Vitest používá základní prvky Vite SSR ke spouštění testů, což s sebou nese určitá úskalí.

Aliasy ovlivňují pouze moduly importované přímo pomocí klíčového slova import vloženým modulem (veškerý zdrojový kód je ve výchozím nastavení vložen).
Vitest nepodporuje aliasing volání require.
Pokud vytváříte alias pro externí závislost (např. react -> preact), zvažte vytvoření aliasu pro skutečné balíčky v node_modules, aby to fungovalo i pro externalizované závislosti. Yarn i pnpm podporují aliasing prostřednictvím předpony npm:.

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í globálních API jako v Jestu, můžete předat možnost --globals do CLI nebo přidat globals: true do konfigurace.

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

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

Aby TypeScript správně 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 použít i pro automatické importování těchto API.

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

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

environment

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

Testovací prostředí, které se použije pro testy. 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č pomocí jsdom nebo happy-dom. Pro edge funkce je k dispozici prostředí edge-runtime.

TIP

Pro spouštění integračních nebo jednotkových testů v prohlížeči bez simulace prostředí můžete také použít Režim prohlížeče.

Pro definování prostředí pro všechny testy v daném souboru můžete použít docblock @vitest-environment nebo komentář na začátku souboru.

Styl docblocku:

/**
 * @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();
});

Pokud spouštíte Vitest s příznakem --isolate=false, testy budou spuštěny v následujícím pořadí: node, jsdom, happy-dom, edge-runtime, custom environments (vlastní prostředí). Testy se stejným prostředím jsou tedy seskupeny a spouštěny sekvenčně.

Od verze 0.23.0 můžete definovat vlastní prostředí. Pokud je použito jiné než vestavěné prostředí, Vitest se pokusí načíst balíček s názvem 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 modulu vitest/environments, pokud je chcete rozšířit. Více informací o rozšiřování prostředí naleznete v našem průvodci.

TIP

Prostředí jsdom zpřístupňuje globální proměnnou jsdom, která je rovna aktuální instanci JSDOM. Pokud chcete, aby ji TypeScript rozpoznal, můžete do svého tsconfig.json přidat vitest/jsdom, když toto prostředí používáte:

json

{
  "compilerOptions": {
    "types": ["vitest/jsdom"]
  }
}

environmentOptions

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

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

environmentMatchGlobs

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

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

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' | 'forks' | 'vmThreads' | 'vmForks' | 'typescript'][]
Výchozí hodnota: []

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

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 `--pool=threads` for them
      ['**/tests/worker-specific/**', 'threads'],
      // run all tests in "browser" directory in an actual browser
      ['**/tests/browser/**', 'browser'],
      // všechny ostatní testy poběží na základě možností "browser.enabled" a "threads", pokud jste nezadali jiné globy
      // ...
    ],
  },
});

update*

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

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

watch*

Typ: boolean
Výchozí hodnota: !process.env.CI
CLI: -w, --watch, --watch=false

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

root

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

Kořenový adresář projektu.

dir

Typ: string
CLI: --dir=<path>
Výchozí: stejné jako root

Základní adresář pro skenování testovacích souborů. Tuto možnost můžete zadat pro urychlení zjištění testů, pokud váš kořen pokrývá celý projekt.

reporters*

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

Definuje vlastní reportéry pro výstup. Reportéři mohou být instance rozhraní Reporter (odkaz), řetězec pro výběr vestavěného reportéru, nebo cesta k vlastní implementaci (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 použita 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.

pool*

Typ: 'threads' | 'forks' | 'vmThreads' | 'vmForks'
Výchozí hodnota: 'forks'
CLI: --pool=threads

Pool, ve kterém se spouští testy.

threads*

Povolí multi-threading pomocí tinypool (odlehčená verze Piscina). Při použití vláken není možné používat API související s procesy, například process.chdir(). Některé knihovny napsané v nativních jazycích, jako je Prisma, bcrypt a canvas, mohou mít problémy při spouštění ve více vláknech a mohou způsobovat segfaulty. V těchto případech se doporučuje použít pool forks.

forks*

Podobné jako pool threads, ale používá child_process místo worker_threads prostřednictvím tinypool. Komunikace mezi testy a hlavním procesem není tak rychlá jako u poolu threads. API související s procesy, jako je process.chdir(), jsou k dispozici v poolu forks.

vmThreads*

Spouští testy pomocí VM context (uvnitř sandboxovaného prostředí) v poolu threads.

To zrychluje spouštění testů, nicméně modul VM je nestabilní při spouštění ESM kódu. Může docházet k úniku paměti - zvažte proto ruční úpravu hodnoty poolOptions.vmThreads.memoryLimit.

WARNING

Spouštění kódu v sandboxu má určité výhody (rychlejší testy), ale také přináší řadu nevýhod.

Globální proměnné v nativních modulech, jako jsou (fs, path atd.), se liší od globálů přítomných ve vašem testovacím prostředí. V důsledku toho bude jakákoli chyba vyvolaná těmito nativními moduly instancí jiného konstruktoru Error, než jaký používáte ve svém kódu:

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

Importované ES moduly jsou ukládány do mezipaměti na neurčito, což může způsobovat úniky paměti, pokud máte velké množství kontextů (testovacích souborů). V Node.js neexistuje žádné API, které by tuto mezipaměť vymazalo.
Přístup ke globálům trvá déle v sandboxovém prostředí.

Při používání této možnosti mějte prosím na paměti tyto problémy. Tým Vitest nemůže tyto problémy na své straně opravit.

vmForks*

Podobné jako pool vmThreads, ale používá child_process místo worker_threads prostřednictvím tinypool. Komunikace mezi testy a hlavním procesem není tak rychlá jako u poolu vmThreads. API související s procesy, jako je process.chdir(), jsou k dispozici v poolu vmForks. Uvědomte si prosím, že tento pool má stejné úskalí jako vmThreads.

poolOptions*

Typ: Record<'threads' | 'forks' | 'vmThreads' | 'vmForks', {}>
Výchozí hodnota: {}

poolOptions.threads

Možnosti pro pool threads.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      threads: {
        // Threads related options here
      },
    },
  },
});

poolOptions.threads.maxThreads*

Typ: number | string
Výchozí: dostupné CPU

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

poolOptions.threads.minThreads*

Typ: number | string
Výchozí: dostupné CPU

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

poolOptions.threads.singleThread

Typ: boolean
Výchozí hodnota: false

Spouští všechny testy se stejným prostředím uvnitř jednoho worker vlákna. Tím se zakáže vestavěná izolace modulů (váš zdrojový kód nebo vložený kód bude stále přehodnocován pro každý test), ale může se zlepšit výkon testů.

WARNING

I když tato možnost vynutí spouštění testů jeden po druhém, liší se od --runInBand v Jestu. 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 budou spouštět 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 ale být zrychlení pro vaše testy (až 3krát rychlejší), které se nutně nespoléhají na globální stav nebo to mohou snadno obejít.

poolOptions.threads.useAtomics*

Typ: boolean
Výchozí hodnota: false

Použije Atomics k synchronizaci vláken.

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.

poolOptions.threads.isolate

Typ: boolean
Výchozí hodnota: true

Izoluje prostředí pro každý testovací soubor.

poolOptions.threads.execArgv*

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

Předá další argumenty do node ve vláknech. Viz Command-line API | Node.js pro více informací.

WARNING

Buďte opatrní při používání, protože některé možnosti mohou způsobit pád workeru, např. --prof, --title. Viz https://github.com/nodejs/node/issues/41103.

poolOptions.forks

Možnosti pro pool forks.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      forks: {
        // Forks related options here
      },
    },
  },
});

poolOptions.forks.maxForks*

Typ: number | string
Výchozí: dostupné CPU

Maximální počet nebo procento procesů.

poolOptions.forks.minForks*

Typ: number | string
Výchozí: dostupné CPU

Minimální počet nebo procento procesů.

poolOptions.forks.isolate

Typ: boolean
Výchozí hodnota: true

Izoluje prostředí pro každý testovací soubor.

poolOptions.forks.singleFork

Typ: boolean
Výchozí hodnota: false

Spouští všechny testy se stejným prostředím uvnitř jednoho podřízeného procesu. Tím se zakáže vestavěná izolace modulů (váš zdrojový kód nebo vložený kód bude stále přehodnocován pro každý test), ale může se zlepšit výkon testů.

WARNING

I když tato možnost vynutí spouštění testů jeden po druhém, liší se od --runInBand v Jestu. Vitest používá podřízené procesy 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 budou spouštět sekvenčně, ale ve stejném globálním kontextu, takže izolaci musíte zajistit sami.

poolOptions.forks.execArgv*

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

Předá další argumenty do procesu node v podřízených procesech. Viz Command-line API | Node.js pro více informací.

WARNING

Buďte opatrní při používání, protože některé možnosti mohou způsobit pád workeru, např. --prof, --title. Viz https://github.com/nodejs/node/issues/41103.

poolOptions.vmThreads

Možnosti pro pool vmThreads.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      vmThreads: {
        // VM threads related options here
      },
    },
  },
});

poolOptions.vmThreads.maxThreads*

Typ: number | string
Výchozí: dostupné CPU

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

poolOptions.vmThreads.minThreads*

Typ: number | string
Výchozí: dostupné CPU

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

poolOptions.vmThreads.memoryLimit*

Typ: string | number
Výchozí hodnota: 1 / CPU Cores

Určuje maximální limit paměti pro workery, po jehož překročení dojde k jejich recyklaci. Tato hodnota výrazně závisí na vašem prostředí, takže je lepší ji zadat ručně, než se spoléhat na výchozí hodnotu.

TIP

Implementace je založena na Jestově workerIdleMemoryLimit.

Limit lze zadat několika různými způsoby a bez ohledu na výsledek se použije Math.floor 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 nemusí fungovat správně na Linux CircleCI workerech (odkaz) z důvodu nesprávně hlášené systémové paměti.

poolOptions.vmThreads.useAtomics*

Typ: boolean
Výchozí hodnota: false

Použije Atomics k synchronizaci vláken.

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.

poolOptions.vmThreads.execArgv*

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

Předá další argumenty do procesu node v kontextu VM. Viz Command-line API | Node.js pro více informací.

WARNING

Buďte opatrní při používání, protože některé možnosti mohou způsobit pád workeru, např. --prof, --title. Viz https://github.com/nodejs/node/issues/41103.

poolOptions.vmForks

Možnosti pro pool vmForks.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      vmForks: {
        // VM forks related options here
      },
    },
  },
});

poolOptions.vmForks.maxForks*

Typ: number | string
Výchozí: dostupné CPU

Maximální počet nebo procento vláken. Můžete také použít proměnnou prostředí VITEST_MAX_FORKS.

poolOptions.vmForks.minForks*

Typ: number | string
Výchozí: dostupné CPU

Minimální počet nebo procento vláken. Můžete také použít proměnnou prostředí VITEST_MIN_FORKS.

poolOptions.vmForks.memoryLimit*

Typ: string | number
Výchozí hodnota: 1 / CPU Cores

poolOptions.vmForks.execArgv*

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

Předá další argumenty do procesu node v kontextu VM. Viz Command-line API | Node.js pro více informací.

WARNING

Buďte opatrní při používání, protože některé možnosti mohou způsobit pád workeru, např. --prof, --title. Viz https://github.com/nodejs/node/issues/41103.

fileParallelism*

Typ: boolean
Výchozí hodnota: true
CLI: --no-file-parallelism, --fileParallelism=false

Určuje, zda se mají všechny testovací soubory spouštět paralelně. Pokud je nastaveno na false, přepíše se nastavení maxWorkers a minWorkers na hodnotu 1.

TIP

Tato možnost nemá vliv na testy uvnitř jednoho souboru. Pro paralelní spouštění testů v rámci souboru použijte možnost concurrent u describe nebo prostřednictvím konfigurace.

maxWorkers*

Type: number | string

Maximální počet workerů pro spouštění testů. poolOptions.{threads,vmThreads}.maxThreads/poolOptions.forks.maxForks má vyšší prioritu.

minWorkers*

Type: number | string

Minimální počet nebo procento workerů pro spouštění testů. poolOptions.{threads,vmThreads}.minThreads/poolOptions.forks.minForks má vyšší prioritu.

testTimeout

Type: number
Výchozí: 5_000 v Node.js, 15_000, pokud je browser.enabled true
CLI: --test-timeout=5000, --testTimeout=5000

Výchozí časový limit testu v milisekundách.

hookTimeout

Type: number
Výchozí: 10_000 v Node.js, 30_000, pokud je browser.enabled true
CLI: --hook-timeout=10000, --hookTimeout=10000

Výchozí časový limit háčku v milisekundách.

teardownTimeout*

Typ: number
Výchozí hodnota: 10000
CLI: --teardown-timeout=5000, --teardownTimeout=5000

Výchozí časový limit pro čekání na ukončení Vitestu v milisekundách.

silent*

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

Potlačí výstup z testů do konzole.

setupFiles

Typ: string | string[]

Cesta k inicializačním souborům (setup files). Tyto soubory se spustí před spuštěním každého testovacího souboru.

INFO

Úprava souboru pro nastavení automaticky spustí opětovné spuštění všech testů.

Uvnitř souborů můžete použít process.env.VITEST_POOL_ID (řetězec reprezentující celé číslo) k rozlišení mezi vlákny.

TIP

Pokud používáte --isolate=false, tento setup soubor se spustí ve stejném globálním rozsahu vícekrát. To znamená, že před každým testem přistupujete ke stejnému globálnímu objektu, takže se ujistěte, že nedochází k opakovanému provádění stejných operací.

Příklad použití globální proměnné:

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

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

// Hooky jsou resetovány před každým balíkem testů
afterEach(() => {
  cleanup();
});

globalThis.resetBeforeEachTest = true;

provide 2.1.0+

Typ: Partial<ProvidedContext>

Definujte hodnoty, ke kterým lze přistupovat ve vašich testech pomocí metody inject.

vitest.config.jsmy.test.js

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    provide: {
      API_KEY: '123',
    },
  },
});

import { expect, inject, test } from 'vitest';

test('api key is defined', () => {
  expect(inject('API_KEY')).toBe('123');
});

WARNING

Vlastnosti musí být řetězce a hodnoty musí být serializovatelné, protože tento objekt bude přenášen mezi různými procesy.

TIP

Pokud používáte TypeScript, budete muset rozšířit typ ProvidedContext pro typově bezpečný přístup:

// vitest.shims.d.ts

declare module 'vitest' {
  export interface ProvidedContext {
    API_KEY: string;
  }
}

// mark this file as a module so augmentation works correctly
export {};

globalSetup

Typ: string | string[]

Cesta ke globálním inicializačním souborům, relativní ke kořenovému adresáři projektu.

Globální inicializační soubor může exportovat pojmenované funkce setup a teardown nebo default funkci, která vrací funkci teardown (příklad).

INFO

Je možné použít více globálních inicializačních souborů. Funkce setup a teardown se spouštějí sekvenčně, přičemž teardown se spouští v obráceném pořadí.

WARNING

Globální setup se spustí pouze v případě, že běží alespoň jeden test. To znamená, že globální setup se může začít spouštět v režimu sledování po změně souboru testu (soubor testu bude čekat na dokončení globálního setupu, než se spustí).

Vezměte na vědomí, že globální setup běží v jiném globálním rozsahu, takže vaše testy nemají přístup k zde definovaným proměnným. Nicméně můžete předat serializovatelná data testům pomocí metody provide:

globalSetup.jsglobalSetup.tsexample.test.js

export default function setup({ provide }) {
  provide('wsPort', 3000);
}

import type { GlobalSetupContext } from 'vitest/node';

export default function setup({ provide }: GlobalSetupContext) {
  provide('wsPort', 3000);
}

declare module 'vitest' {
  export interface ProvidedContext {
    wsPort: number;
  }
}

import { inject } from 'vitest';

inject('wsPort') === 3000;

forceRerunTriggers*

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

Glob vzor pro cesty k souborům, které vyvolají opakované spuštění celé sady testů. V kombinaci s argumentem --changed se spustí celá sada testů, pokud je daný soubor změněn v git diffu.

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

test('execute a script', async () => {
  // Vitest nemůže opakovat tento test, pokud se změní obsah `dist/index.js`
  await execa('node', ['dist/index.js']);
});

TIP

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

coverage*

Pro zjišťování pokrytí kódu můžete použít v8, istanbul nebo vlastní řešení.

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í, nezapomeňte zadat --coverage.enabled. V takovém případě nezadávejte pouze --coverage.

coverage.provider

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

Určuje nástroj pro zjišťování pokrytí kódu.

coverage.enabled

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

Povolí zjišťování pokrytí kódu. Lze přepsat pomocí možnosti CLI --coverage.

coverage.include

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

coverage.exclude

Typ: string[]
Výchozí hodnota:

[
  'coverage/**',
  'dist/**',
  '**/node_modules/**',
  '**/[.]**',
  'packages/*/test?(s)/**',
  '**/*.d.ts',
  '**/virtual:*',
  '**/__x00__*',
  '**/\x00*',
  'cypress/**',
  'test?(s)/**',
  'test?(-*).?(c|m)[jt]s?(x)',
  '**/*{.,-}{test,spec,bench,benchmark}?(-d).?(c|m)[jt]s?(x)',
  '**/__tests__/**',
  '**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.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í, pomocí glob vzorů.

Tato možnost přepisuje všechny výchozí možnosti. Rozšiřte výchozí možnosti při přidávání nových vzorů k ignorování:

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

export default defineConfig({
  test: {
    coverage: {
      exclude: ['**/custom-pattern/**', ...coverageConfigDefaults.exclude],
    },
  },
});

POZNÁMKA

Vitest automaticky přidává vzory include testovacích souborů do výchozí hodnoty coverage.exclude.

coverage.all

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

Určuje, zda se mají do reportu zahrnout všechny soubory, i ty netestované.

coverage.clean

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

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

coverage.cleanOnRerun

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

Vyčistit sestavu pokrytí při opětovném spuštění s hlídáním. Nastavte na false pro zachování výsledků pokrytí z předchozího spuštění v režimu hlídání.

coverage.reportsDirectory

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

WARNING

Vitest odstraní tento adresář před spuštěním testů, pokud je povoleno coverage.clean (výchozí hodnota).

Adresář, do kterého se má zapisovat report pokrytí.

Chcete-li zobrazit náhled sestavy pokrytí ve výstupu HTML reporteru, musí být tato možnost nastavena jako podadresář adresáře sestavy HTML (například ./html/coverage).

coverage.reporter

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

Reporty 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 reportéru:

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

Můžete také předat vlastní reportéry pokrytí. Více informací naleznete v Příručce – Vlastní reportér pokrytí.

{
  reporter: [
    // Specify reporter using name of the NPM package
    '@vitest/custom-coverage-reporter',
    ['@vitest/custom-coverage-reporter', { someOption: true }],

    // Specify reporter using local path
    '/absolute/path/to/custom-reporter.cjs',
    ['/absolute/path/to/custom-reporter.cjs', { someOption: true }],
  ];
}

Zprávu o pokrytí si můžete prohlédnout v uživatelském rozhraní Vitest: další podrobnosti naleznete v Pokrytí Vitest UI.

coverage.reportOnFailure

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

Generuje sestavu pokrytí, i když testy selžou.

coverage.allowExternal

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

Zjišťuje pokrytí souborů mimo kořenový adresář projektu root.

coverage.excludeAfterRemap 2.1.0+

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

Znovu použít vyloučení po opětovném namapování pokrytí na původní zdroje. To je užitečné, když jsou vaše zdrojové soubory přeloženy a mohou obsahovat source mapy nesouvisejících souborů.

Použijte tuto možnost, když se v reportu zobrazují soubory, i když odpovídají vašim vzorům coverage.exclude.

coverage.skipFull

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

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

coverage.thresholds

Možnosti pro prahové hodnoty pokrytí.

coverage.thresholds.lines

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

Globální prahová hodnota pro řádky. Další informace naleznete v dokumentaci istanbul.

coverage.thresholds.functions

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

Globální prahová hodnota pro funkce. Další informace naleznete v dokumentaci istanbul.

coverage.thresholds.branches

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

Globální prahová hodnota pro větve. Další informace naleznete v dokumentaci istanbul.

coverage.thresholds.statements

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

Globální prahová hodnota pro příkazy. Další informace naleznete v dokumentaci istanbul.

coverage.thresholds.perFile

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

Ověřuje prahové hodnoty pro každý soubor.

coverage.thresholds.autoUpdate

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

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

coverage.thresholds.100

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

Nastaví globální prahové hodnoty na 100. Zkratka pro --coverage.thresholds.lines 100 --coverage.thresholds.functions 100 --coverage.thresholds.branches 100 --coverage.thresholds.statements 100.

coverage.thresholds[glob-pattern]

Typ: { statements?: number functions?: number branches?: number lines?: number }
Výchozí hodnota: undefined
Dostupné pro poskytovatele: 'v8' | 'istanbul'

Nastaví prahové hodnoty pro soubory odpovídající glob vzoru.

POZNÁMKA

Vitest započítává všechny soubory, včetně těch pokrytých glob vzory, do globálních prahových hodnot pokrytí kódu. To se liší od chování Jest.

{
  coverage: {
    thresholds: {
      // Thresholds for all files
      functions: 95,
      branches: 70,

      // Thresholds for matching glob pattern
      'src/utils/**.ts': {
        statements: 95,
        functions: 90,
        branches: 85,
        lines: 80,
      },

      // Files matching this pattern will only have lines thresholds set.
      // Global thresholds are not inherited.
      '**/math.ts': {
        lines: 100,
      }
    }
  }
}

coverage.thresholds[glob-pattern].100 2.1.0+

Typ: boolean
Výchozí: false
Dostupné pro poskytovatele: 'v8' | 'istanbul'

Nastaví prahové hodnoty na 100 pro soubory odpovídající glob vzoru.

{
  coverage: {
    thresholds: {
      // Prahové hodnoty pro všechny soubory
      functions: 95,
      branches: 70,

      // Prahové hodnoty pro soubory odpovídající glob vzoru
      'src/utils/**.ts': { 100: true },
      '**/math.ts': { 100: true }
    }
  }
}

coverage.ignoreEmptyLines

Typ: boolean
Výchozí hodnota: true (false ve verzi v1)
Dostupné pro poskytovatele: 'v8'
CLI: --coverage.ignoreEmptyLines=<boolean>

Ignoruje prázdné řádky, komentáře a další kód, který není spouštěn, např. Typescript typy.

Tato možnost funguje pouze v případě, že použitý kompilátor odstraní komentáře a další neruntime kód z transpilovaného kódu. Ve výchozím nastavení používá Vite ESBuild, který odstraňuje komentáře a Typescript typy ze souborů .ts, .tsx a .jsx.

Pokud chcete použít ESBuild i na jiné soubory, definujte je v možnostech esbuild:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  esbuild: {
    // Transpile all files with ESBuild to remove comments from code coverage.
    include: ['**/*.js', '**/*.jsx', '**/*.mjs', '**/*.ts', '**/*.tsx'],
  },
  test: {
    coverage: {
      provider: 'v8',
      ignoreEmptyLines: true,
    },
  },
});

coverage.ignoreClassMethods

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

Nastavte pole názvů metod třídy, které se mají ignorovat při pokrytí. Další informace naleznete v dokumentaci istanbul.

coverage.watermarks

Typ:

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

Výchozí hodnota:

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

Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.watermarks.statements=50,80, --coverage.watermarks.branches=50,80

Watermarky pro pokrytí příkazů, řádků, větví a funkcí. Další informace naleznete v dokumentaci istanbul.

coverage.processingConcurrency

Typ: boolean
Výchozí hodnota: Math.min(20, os.availableParallelism?.() ?? os.cpus().length)
Dostupné pro poskytovatele: 'v8' | 'istanbul'
CLI: --coverage.processingConcurrency=<number>

Limit souběžnosti používaný při zpracování výsledků pokrytí.

coverage.customProviderModule

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

Určuje název modulu nebo cestu k vlastnímu modulu pro zjišťování pokrytí. Další informace naleznete v Průvodci - Vlastní poskytovatel pokrytí.

testNamePattern*

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

Spustí testy, jejichž úplné názvy odpovídají zadanému vzoru. Pokud je tato vlastnost použita s OnlyRunThis, spustí se pouze testy, které obsahují v názvu OnlyRunThis. Ostatní testy budou přeskočeny.

import { expect, test } from 'vitest';

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

// přeskočí se
test('doNotRun', () => {
  expect(true).toBe(true);
});

open*

Typ: boolean
Výchozí: !process.env.CI
CLI: --open, --open=false

Otevře Vitest UI (ve vývoji).

api

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

Spustí server na daném portu a zpřístupní API. Pokud je nastaveno na true, použije se výchozí port 51204.

browser

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

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

POZNÁMKA

Více informací o testování v reálném prohlížeči naleznete na stránce s průvodcem.

WARNING

Jedná se o experimentální funkci. Zásadní změny nemusí dodržovat SemVer, proto doporučujeme při jejím používání zafixovat verzi Vitest.

browser.enabled

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

Pokud je nastaveno na true, spustí všechny testy v prohlížeči. Lze přepsat pomocí možnosti poolMatchGlobs.

browser.name

Typ: string
CLI: --browser=safari

Spustí testy v konkrétním prohlížeči. Dostupné možnosti se liší podle poskytovatele:

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

browser.headless

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

Spustí prohlížeč v režimu headless. Pokud spouštíte Vitest v CI (Continuous Integration), bude ve výchozím nastavení povoleno.

browser.isolate

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

Spustí každý test v samostatném iframe.

browser.testerHtmlPath

Typ: string
Výchozí: @vitest/browser/tester.html
Verze: Od Vitest 2.1.4

Cesta k HTML vstupnímu bodu. Může být relativní od kořene projektu. Tento soubor bude zpracován pomocí hooku transformIndexHtml.

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 Vite server, který obsluhuje kód v prohlížeči. Neovlivňuje test.api možnost. Ve výchozím nastavení Vitest přiřadí port 63315, aby se předešlo konfliktům s vývojovým serverem, což vám umožní spouštět oba paralelně.

browser.provider

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

Cesta k provideru, který bude použit při spouštění testů v prohlížeči. Vitest poskytuje tři provideři: preview (výchozí), webdriverio a playwright. Vlastní provideři by měli být exportováni pomocí default exportu a mít tuto podobu:

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

WARNING

Jedná se o pokročilé API pro autory knihoven. Pokud potřebujete pouze spouštět testy v prohlížeči, použijte možnost browser.

browser.providerOptions

Typ: BrowserProviderOptions

Možnosti, které budou předány poskytovateli při inicializaci.

export default defineConfig({
  test: {
    browser: {
      providerOptions: {
        launch: {
          devtools: true,
        },
      },
    },
  },
});

TIP

Pro zajištění lepší typové bezpečnosti při používání vestavěných poskytovatelů můžete přidat jeden z následujících typů (pro poskytovatele, kterého používáte) do pole compilerOptions.types ve vašem tsconfig:

json

{
  "compilerOptions": {
    "types": [
      "@vitest/browser/providers/webdriverio",
      "@vitest/browser/providers/playwright"
    ]
  }
}

browser.ui

Typ: boolean
Výchozí: !isCI
CLI: --browser.ui=false

Zda má být Vitest UI vloženo do stránky. Ve výchozím nastavení vkládá UI iframe během vývoje.

browser.viewport

Typ: { width, height }
Výchozí: 414x896

Výchozí viewport iframe.

browser.locators

Možnosti pro vestavěné lokalizátory prohlížeče.

browser.locators.testIdAttribute

Typ: string
Výchozí: data-testid

Atribut používaný k nalezení prvků pomocí lokalizátoru getByTestId.

browser.screenshotDirectory

Typ: string
Výchozí: __snapshots__ v adresáři testovacích souborů

Cesta k adresáři snímků vzhledem k root.

browser.screenshotFailures

Typ: boolean
Výchozí: !browser.ui

Má Vitest pořizovat snímky obrazovky, pokud test selže?

browser.orchestratorScripts

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

Vlastní skripty, které by se měly vložit do orchestrator HTML před spuštěním testovacích iframe. Tento HTML dokument pouze nastavuje iframe a ve skutečnosti neimportuje váš kód.

Skripty src a content budou zpracovány pomocí Vite pluginů. Skript by měl být poskytnut v následujícím tvaru:

export interface BrowserScript {
  /**
   * Pokud je poskytnut "content" a typ je "module", toto bude jeho identifikátor.
   *
   * Pokud používáte TypeScript, můžete zde přidat například příponu `.ts`.
   * @default `injected-${index}.js`
   */
  id?: string;
  /**
   * JavaScriptový obsah, který má být vložen. Tento řetězec je zpracován pomocí Vite pluginů, pokud je typ "module".
   *
   * Můžete použít `id` k poskytnutí nápovědy Vite o příponě souboru.
   */
  content?: string;
  /**
   * Cesta ke skriptu. Tato hodnota je vyřešena pomocí Vite, takže může být node module nebo cesta k souboru.
   */
  src?: string;
  /**
   * Pokud by měl být skript načten asynchronně.
   */
  async?: boolean;
  /**
   * Typ skriptu.
   * @default 'module'
   */
  type?: string;
}

browser.testerScripts

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

Vlastní skripty, které by měly být vloženy do tester HTML před inicializací testovacího prostředí. To je užitečné pro vložení polyfillů potřebných pro implementaci Vitest v prohlížeči. Doporučuje se používat setupFiles téměř ve všech případech namísto tohoto.

Skripty src a content budou zpracovány pomocí Vite pluginů.

browser.commands

Typ: Record<string, BrowserCommand>
Výchozí: { readFile, writeFile, ... }

Vlastní příkazy, které lze importovat během testů v prohlížeči z @vitest/browser/commands.

clearMocks

Typ: boolean
Výchozí: false

Před každým testem zavolá [.mockClear()](../api/mock#mockclear) na všechny špehy. Tím se vymaže stav mocků, ale neobnoví se jejich implementace na výchozí.

mockReset

Typ: boolean
Výchozí: false

Před každým testem zavolá [.mockReset()](../api/mock#mockreset) na všechny špehy. Tím se vymaže stav mocků a obnoví se jejich implementace na prázdnou funkci (vrátí undefined).

restoreMocks

Typ: boolean
Výchozí: false

Před každým testem zavolá [.mockRestore()](../api/mock#mockrestore) na všechny špehy. Tím se vymaže stav mocků a obnoví se jejich implementace na původní.

unstubEnvs

Typ: boolean
Výchozí: false

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

unstubGlobals

Typ: boolean
Výchozí: false

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

testTransformMode

Typ: { web?, ssr? }

Určuje metodu transformace pro všechny moduly importované uvnitř testu, které odpovídají glob vzoru. Ve výchozím nastavení se spoléhá na prostředí. Například testy s prostředím JSDOM zpracují všechny soubory s příznakem ssr: false a testy s prostředím Node zpracují všechny moduly s ssr: true.

testTransformMode.ssr

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

Použije transformační pipeline SSR (Server-Side Rendering) pro všechny moduly v zadaných testech.
Vite pluginy obdrží příznak ssr: true při zpracování těchto souborů.

testTransformMode.web

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

Provede normální transformační pipeline (cílení na prohlížeč) a poté provede SSR rewrite 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ány do pretty-format.

TIP

Upozorňujeme, že pole plugins bude ignorováno.

Pokud potřebujete rozšířit snapshot serializer pomocí pretty-format pluginů, použijte prosím expect.addSnapshotSerializer API nebo možnost snapshotSerializers.

snapshotSerializers*

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

Seznam cest k modulům snapshot serializerů pro snapshot testing. Užitečné, pokud chcete přidat vlastní snapshot serializery. Více informací naleznete v Custom Serializer.

resolveSnapshotPath*

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

Přepíše výchozí cestu k snapshotu. Například pro uložení snapshotů vedle testovacích souborů:

import { defineConfig } from 'vitest/config';

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

allowOnly

Typ: boolean
Výchozí: !process.env.CI
CLI: --allowOnly, --allowOnly=false

Povolí spouštění testů a testovacích sad, které jsou označeny 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 neselže, pokud nebyly nalezeny žádné testy.

logHeapUsage

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

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

css

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

Konfiguruje, zda má být CSS zpracováno. Při vyloučení budou soubory CSS nahrazeny prázdnými řetězci, aby se obešlo následné zpracování. CSS Modules vrátí proxy, aby neovlivnily běh testů.

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 se rozhodnete zpracovávat CSS soubory, můžete nakonfigurovat, jak se mají názvy tříd v CSS modulech chovat. 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 používáte funkci snapshot.
scoped: názvy tříd budou generovány jako obvykle, s ohledem na metodu css.modules.generateScopedName, 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 nijak upravovány.

WARNING

Ve výchozím nastavení Vitest exportuje proxy, čímž 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í možnosti include.

maxConcurrency

Typ: number
Výchozí: 5
CLI: --max-concurrency=10, --maxConcurrency=10

Maximální počet testů označených test.concurrent, které mohou běžet současně.

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

cache*

Typ: false
CLI: --no-cache, --cache=false

Tuto volbu použijte, pokud chcete zakázat ukládání do mezipaměti. Vitest ukládá výsledky testů do mezipaměti, aby upřednostnil spouštění dlouhotrvajících a neúspěšných testů.

Adresář mezipaměti je řízen možností Vite cacheDir:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  cacheDir: 'custom-folder/.vitest',
});

Adresář můžete omezit pouze pro Vitest pomocí process.env.VITEST:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  cacheDir: process.env.VITEST ? 'custom-folder/.vitest' : undefined,
});

sequence

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

Možnosti pro určení způsobu řazení testů.

Možnosti sekvence můžete zadat v 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 rozdělení (sharding) a řazení testů. Můžete rozšířit BaseSequencer z vitest/node, pokud potřebujete redefinovat pouze jednu z metod sort a shard, ale obě metody by měly existovat.

Rozdělení (sharding) se provádí před řazením, a to pouze pokud je zadána možnost --shard.

sequence.shuffle

Typ: boolean | { files?, tests? }
Výchozí: false
CLI: --sequence.shuffle, --sequence.shuffle=false

Pokud chcete, aby se soubory a testy spouštěly v náhodném pořadí, povolte tuto možnost nebo použijte argument CLI --sequence.shuffle.

Vitest obvykle používá mezipaměť k řazení testů, takže dlouhotrvající testy se spouštějí dříve, což urychluje testování. Pokud povolíte náhodné spouštění souborů a testů, ztratíte tuto optimalizaci výkonu, ale může to pomoci odhalit testy, které neúmyslně závisí na předchozím běhu.

sequence.shuffle.files

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

Určuje, zda se mají soubory randomizovat. Povolení této možnosti způsobí, že dlouhotrvající testy nebudou spouštěny s prioritou.

sequence.shuffle.tests

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

Určuje, zda se mají testy randomizovat.

sequence.concurrent

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

Pokud chcete, aby se testy spouštěly paralelně, povolte tuto možnost nebo použijte argument CLI --sequence.concurrent.

sequence.seed*

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

Nastaví seed pro randomizaci testů, pokud se 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í, ve které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).

TIP

Tato možnost nemá vliv na onTestFinished a vždy se volá v opačném pořadí.

sequence.setupFiles

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

Změní pořadí, ve kterém jsou spouštěny 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.enabled

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

Povolí kontrolu typů spolu s běžnými testy.

typecheck.only

Typ: boolean
Výchozí: false
CLI: --typecheck.only

Spustí pouze testy kontroly typů, pokud je kontrola typů povolena. Při použití CLI tato možnost automaticky povolí kontrolu typů.

typecheck.checker

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

Určuje, který nástroj se má použít pro kontrolu typů. Vitest spustí proces s určitými parametry pro snadnější parsování, v závislosti na typu. Checker by měl implementovat stejný formát výstupu jako tsc.

Pro použití typecheckeru musíte mít nainstalovaný odpovídající balíček:

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

Můžete také zadat cestu k vlastnímu binárnímu souboru 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 vzor pro soubory, které mají být považovány za testovací soubory.

typecheck.exclude

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

Glob vzor pro soubory, které nemají být považovány za testovací soubory.

typecheck.allowJs

Typ: boolean
Výchozí: false

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

typecheck.ignoreSourceErrors

Typ: boolean
Výchozí: false

Pokud Vitest najde chyby mimo testovací soubory, testy selžou. Ve výchozím nastavení se chyby mimo testovací soubory nezobrazují.

Chyba ve zdrojovém kódu ve výchozím nastavení způsobí selhání testovací sady.

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
CLI: --slow-test-threshold=<number>, --slowTestThreshold=<number>

Počet milisekund, po kterém je test nebo sada testů považována za pomalou a jako taková je nahlášena ve výsledcích.

chaiConfig

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

Ekvivalentní konfiguraci Chai.

chaiConfig.includeStack

Typ: boolean
Výchozí: false

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

chaiConfig.showDiff

Typ: boolean
Výchozí: true

Ovlivňuje, zda má být příznak showDiff zahrnut do vyvolaných AssertionError. false bude vždy false; true bude platit, pokud assertion vyžaduje zobrazení rozdílu (diff).

chaiConfig.truncateThreshold

Typ: number
Výchozí: 40

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

Tato možnost konfigurace ovlivňuje zkracování hodnot v titulcích test.each a uvnitř chybové zprávy assertion.

bail

Typ: number
Výchozí: 0
CLI: --bail=<value>

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

To může být nežádoucí v CI, kde je cílem 100% úspěšnost a je žádoucí zastavit provádění testů co nejdříve po selhání. Možnost bail urychluje CI tím, že zabrání spouštění dalších testů po selhání.

retry

Typ: number
Výchozí: 0
CLI: --retry=<value>

Opakuje test zadaný početkrát, pokud selže.

onConsoleLog*

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

Vlastní obslužná rutina pro console.log v rámci testů. Pokud vrátíte false, Vitest nezobrazí protokol v konzoli.

Může být užitečné pro filtrování protokolů z knihoven třetích stran.

import { defineConfig } from 'vitest/config';

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

onStackTrace*

Typ: (error: Error, frame: ParsedStack) => boolean | void

Aplikuje funkci filtrování na každý rámec trasování zásobníku při zpracování chyb. První argument, error, je objekt se stejnými vlastnostmi jako standardní Error, ale není to skutečná instance.

Může být užitečné pro filtrování rámců trasování zásobníku z knihoven třetích stran.

import type { ParsedStack } from 'vitest';
import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    onStackTrace(error: Error, { file }: ParsedStack): boolean | void {
      // Pokud jsme narazili na ReferenceError, zobrazíme celý zásobník.
      if (error.name === 'ReferenceError') return;

      // Odmítneme všechny rámce z knihoven třetích stran.
      if (file.includes('node_modules')) return false;
    },
  },
});

diff

Typ: string
CLI: --diff=<value>

Cesta k souboru s nastavením diff, který se použije pro generování diff rozhraní. Užitečné, pokud chcete přizpůsobit zobrazení diff.

vitest.diff.tsvitest.config.js

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

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

diff.truncateThreshold

Typ: number
Výchozí: 0

Maximální délka zobrazeného výsledku diff. Diffs nad touto prahovou hodnotou budou zkráceny. Zkrácení se neprojeví s výchozí hodnotou 0.

diff.truncateAnnotation

Typ: string
Výchozí: '... Diff result is truncated'

Poznámka, která se zobrazí na konci zkráceného diff výsledku, pokud je zkrácen.

diff.truncateAnnotationColor

Typ: DiffOptionsColor = (arg: string) => string
Výchozí: noColor = (string: string): string => string

Barva anotace zkrácení, výchozí je výstup bez barvy.

fakeTimers

Typ: FakeTimerInstallOpts

Možnosti, které Vitest předává do @sinon/fake-timers při použití vi.useFakeTimers().

fakeTimers.now

Typ: number | Date
Výchozí: Date.now()

Nainstaluje falešné časovače s danou Unix epochou.

fakeTimers.toFake

Typ: ('setTimeout' | 'clearTimeout' | 'setImmediate' | 'clearImmediate' | 'setInterval' | 'clearInterval' | 'Date' | 'nextTick' | 'hrtime' | 'requestAnimationFrame' | 'cancelAnimationFrame' | 'requestIdleCallback' | 'cancelIdleCallback' | 'performance' | 'queueMicrotask')[]
Výchozí: ['setTimeout', 'clearTimeout', 'setImmediate', 'clearImmediate', 'setInterval', 'clearInterval', 'Date']

Pole názvů globálních metod a API, které se mají mockovat.

Pro mockování pouze setTimeout() a nextTick() nastavte tuto vlastnost na ['setTimeout', 'nextTick'].

Simulace nextTick není podporována, pokud je Vitest spuštěn v node:child_process s použitím --pool=forks. NodeJS interně používá process.nextTick v node:child_process, což vede k zablokování při mockování. Simulace nextTick je podporována, pokud je Vitest spuštěn s --pool=threads.

fakeTimers.loopLimit

Typ: number
Výchozí: 10_000

Maximální počet časovačů spuštěných při volání vi.runAllTimers().

fakeTimers.shouldAdvanceTime

Typ: boolean
Výchozí: false

Nastavuje @sinonjs/fake-timers tak, aby automaticky inkrementoval mockovaný čas na základě posunu reálného systémového času (např. mockovaný čas se inkrementuje o 20 ms za každých 20 ms změny reálného systémového času).

fakeTimers.advanceTimeDelta

Typ: number
Výchozí: 20

Relevantní pouze při použití s shouldAdvanceTime: true. Inkrementuje mockovaný čas o advanceTimeDelta ms pro každou změnu advanceTimeDelta ms ve skutečném systémovém čase.

fakeTimers.shouldClearNativeTimers

Typ: boolean
Výchozí: true

Říká falešným časovačům, aby vyčistily "nativní" (tj. nefalešné) časovače delegováním na jejich příslušné handlery. Je-li zakázáno, může to vést k potenciálně neočekávanému chování, pokud časovače existovaly před spuštěním relace falešných časovačů.

workspace*

Typ: string
CLI: --workspace=./file.js
Výchozí: vitest.{workspace,projects}.{js,ts,json} blízko konfiguračního souboru nebo kořene

Cesta ke konfiguračnímu souboru workspace relativní k root.

isolate

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

Spouští testy v izolovaném prostředí. Tato možnost nemá žádný vliv na pooly vmThreads a vmForks.

Zakázání této možnosti může zvýšit výkon, pokud kód nevyužívá vedlejší efekty (typické pro projekty s prostředím node).

TIP

Izolaci můžete zakázat pro konkrétní pooly pomocí vlastnosti poolOptions.

includeTaskLocation

Typ: boolean
Výchozí: false

Určuje, zda má být vlastnost location zahrnuta, když Vitest API přijímá úkoly v reporters. Pokud máte hodně testů, může to způsobit malou regresi výkonu.

Vlastnost location má hodnoty column a line, které odpovídají pozici test nebo describe v původním souboru.

Tato možnost bude automaticky povolena, pokud ji explicitně nezakážete a spouštíte Vitest s:

Vitest UI
nebo pomocí Režimu prohlížeče bez režimu headless
nebo pomocí Reportéra HTML

TIP

Tato možnost nemá žádný vliv, pokud nepoužíváte vlastní kód, který na tom závisí.

snapshotEnvironment

Typ: string

Cesta k vlastní implementaci prostředí snapshot. To je užitečné, pokud spouštíte testy v prostředí, které nepodporuje Node.js API. Tato možnost nemá vliv na spouštění v prohlížeči.

Tento objekt by měl mít tvar SnapshotEnvironment a používá se k řešení a čtení/zápisu souborů snapshotů:

export interface SnapshotEnvironment {
  getVersion: () => string;
  getHeader: () => string;
  resolvePath: (filepath: string) => Promise<string>;
  resolveRawPath: (testPath: string, rawPath: string) => Promise<string>;
  saveSnapshotFile: (filepath: string, snapshot: string) => Promise<void>;
  readSnapshotFile: (filepath: string) => Promise<string | null>;
  removeSnapshotFile: (filepath: string) => Promise<void>;
}

Pro úpravu pouze části API můžete rozšířit výchozí VitestSnapshotEnvironment z vitest/snapshot.

WARNING

Tato nízkoúrovňová možnost je určena pouze pro pokročilé případy, kdy není přístup k výchozím Node.js API.

Pro konfiguraci snapshotů použijte snapshotFormat nebo resolveSnapshotPath.

env

Typ: Partial<NodeJS.ProcessEnv>

Proměnné prostředí dostupné na process.env a import.meta.env během testů. Tyto proměnné nebudou dostupné v hlavním procesu (například v globalSetup).

expect

Typ: ExpectOptions

expect.requireAssertions

Typ: boolean
Výchozí: false

Stejné jako volání expect.hasAssertions() na začátku každého testu. To zajišťuje, že žádný test neprojde náhodou.

TIP

Toto funguje pouze s expect z Vitestu. Pokud používáte tvrzení assert nebo .should, nebudou se počítat a váš test selže kvůli nedostatku tvrzení expect.

Hodnotu lze změnit voláním vi.setConfig({ expect: { requireAssertions: false } }). Konfigurace se použije pro každý následný volání expect až do ručního volání vi.resetConfig.

expect.poll

Globální možnosti konfigurace pro expect.poll. Jedná se o stejné možnosti, které můžete předat do expect.poll(condition, options).

expect.poll.interval

Typ: number
Výchozí: 50

Interval dotazování v milisekundách

expect.poll.timeout

Typ: number
Výchozí: 1000

Časový limit dotazování v milisekundách

printConsoleTrace

Typ: boolean
Výchozí: false

Vždy tisknout trasování konzole při volání libovolné metody console. To je užitečné pro ladění.

Konfigurace Vitest ​

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.interopDefault ​

deps.moduleDirectories ​

runner ​

benchmark ​

benchmark.include ​

benchmark.exclude ​

benchmark.includeSource ​

benchmark.reporters ​

benchmark.outputFile ​

benchmark.outputJson ​

benchmark.compare ​

alias ​

globals ​

environment ​

environmentOptions ​

environmentMatchGlobs ​

poolMatchGlobs ​

update* ​

watch* ​

root ​

dir ​

reporters* ​

outputFile* ​

pool* ​

threads* ​

forks* ​

vmThreads* ​

vmForks* ​

poolOptions* ​

poolOptions.threads ​

poolOptions.threads.maxThreads* ​

poolOptions.threads.minThreads* ​

poolOptions.threads.singleThread ​

poolOptions.threads.useAtomics* ​

poolOptions.threads.isolate ​

poolOptions.threads.execArgv* ​

poolOptions.forks ​

poolOptions.forks.maxForks* ​

poolOptions.forks.minForks* ​

poolOptions.forks.isolate ​

poolOptions.forks.singleFork ​

poolOptions.forks.execArgv* ​

poolOptions.vmThreads ​

poolOptions.vmThreads.maxThreads* ​

poolOptions.vmThreads.minThreads* ​

poolOptions.vmThreads.memoryLimit* ​

poolOptions.vmThreads.useAtomics* ​

poolOptions.vmThreads.execArgv* ​

poolOptions.vmForks ​

poolOptions.vmForks.maxForks* ​

poolOptions.vmForks.minForks* ​

poolOptions.vmForks.memoryLimit* ​

poolOptions.vmForks.execArgv* ​

fileParallelism* ​

maxWorkers* ​

minWorkers* ​

testTimeout ​

hookTimeout ​

teardownTimeout* ​

Konfigurace Vitest

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.interopDefault

deps.moduleDirectories

runner

benchmark

benchmark.include

benchmark.exclude

benchmark.includeSource

benchmark.reporters

benchmark.outputFile

benchmark.outputJson

benchmark.compare

alias

globals

environment

environmentOptions

environmentMatchGlobs

poolMatchGlobs

update*

watch*

root

dir

reporters*

outputFile*

pool*

threads*

forks*

vmThreads*

vmForks*

poolOptions*

poolOptions.threads

poolOptions.threads.maxThreads*

poolOptions.threads.minThreads*

poolOptions.threads.singleThread

poolOptions.threads.useAtomics*

poolOptions.threads.isolate

poolOptions.threads.execArgv*

poolOptions.forks

poolOptions.forks.maxForks*

poolOptions.forks.minForks*

poolOptions.forks.isolate

poolOptions.forks.singleFork

poolOptions.forks.execArgv*

poolOptions.vmThreads

poolOptions.vmThreads.maxThreads*

poolOptions.vmThreads.minThreads*

poolOptions.vmThreads.memoryLimit*

poolOptions.vmThreads.useAtomics*

poolOptions.vmThreads.execArgv*

poolOptions.vmForks

poolOptions.vmForks.maxForks*

poolOptions.vmForks.minForks*

poolOptions.vmForks.memoryLimit*

poolOptions.vmForks.execArgv*

fileParallelism*

maxWorkers*

minWorkers*

testTimeout

hookTimeout

teardownTimeout*