Konfigurace Vitestu

Pokud používáte Vite a máte soubor vite.config, Vitest jej automaticky načte, aby se shodoval s pluginy a nastavením vaší aplikace Vite. Pokud chcete mít odlišnou konfiguraci pro testování, nebo pokud vaše hlavní aplikace není závislá na Vite, máte následující možnosti:

Vytvořte soubor vitest.config.ts. Tento soubor bude mít vyšší prioritu a přepíše konfiguraci ze souboru vite.config.ts (Vitest podporuje všechny běžné přípony JS a TS, ale nepodporuje json). To znamená, že všechny možnosti ve vašem vite.config budou ignorovány.
Předejte parametr --config do CLI, např. vitest --config ./path/to/vitest.config.ts.
Použijte process.env.VITEST nebo vlastnost mode v defineConfig (bude nastavena na test/benchmark, pokud není přepsána pomocí --mode) pro podmíněné použití odlišné konfigurace v vite.config.ts.

Pro konfiguraci samotného Vitestu přidejte vlastnost test do vaší Vite konfigurace. Budete také muset přidat odkaz na typy Vitestu pomocí triple slash command na začátek vašeho konfiguračního souboru, pokud importujete defineConfig přímo z vite.

Otevřít příklady konfigurace

Při použití defineConfig z vite postupujte takto:

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

export default defineConfig({
  test: {
    // ... Zde specifikujte možnosti.
  },
});

<reference types="vitest" /> přestane fungovat ve Vitestu 4, ale již nyní můžete migrovat na vitest/config:

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

export default defineConfig({
  test: {
    // ... Zde specifikujte možnosti.
  },
});

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

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    // ... Zde specifikujte možnosti.
  },
});

Můžete získat výchozí možnosti Vitestu a v případě potřeby je rozšířit:

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

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

Při použití samostatného vitest.config.js můžete také rozšířit možnosti Vite z jiného konfiguračního souboru v případě potřeby:

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

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

Pokud je vaše Vite konfigurace definována funkcí, můžete konfiguraci 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/*'],
      },
    })
  )
);

WARNING

Všechny uvedené možnosti na této stránce se nacházejí ve vlastnosti test v konfiguraci:

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

Protože Vitest používá Vite konfiguraci, 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ů – tyto možnosti by měly být definovány na nejvyšší úrovni, ne ve vlastnosti test.

Konfigurační možnosti, které nejsou podporovány v konfiguraci projektu, mají vedle sebe značku *. To znamená, že je lze nastavit pouze v kořenové konfiguraci Vitestu.

include

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

Seznam glob vzorů, které se shodují s vašimi testovacími soubory.

POZNÁMKA

Při použití pokrytí Vitest automaticky přidává vzory include pro testovací soubory 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,eslint,prettier}.config.*']
CLI: vitest --exclude "**/excluded-file"

Seznam glob vzorů, které by měly být vyloučeny z vašich testovacích souborů.

WARNING

Tato možnost neovlivňuje pokrytí. Pokud potřebujete odstranit určité soubory ze zprávy o pokrytí, použijte coverage.exclude.

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

includeSource

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

Zahrnout globy pro testovací soubory přímo ve zdrojovém kódu.

Pokud je definováno, Vitest spustí všechny odpovídající soubory s import.meta.vitest uvnitř.

name

Typ: string | { label: string, color?: LabelColor }

Přiřadí vlastní název testovacímu projektu nebo procesu Vitest. Název bude viditelný v CLI a UI a dostupný v Node.js API přes project.name.

Barvu použitou v CLI a UI lze změnit zadáním objektu s vlastností color.

server

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

Možnosti serveru Vite-Node.

server.sourcemap

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

Vložit inline zdrojovou mapu do modulů.

server.debug

Typ: { dumpModules?, loadDumppedModules? }

Možnosti debuggeru Vite-Node.

server.debug.dumpModules

Typ: boolean | string

Vypsat transformovaný modul do souborového systému. Zadání řetězce vypíše do zadané cesty.

server.debug.loadDumppedModules

Typ: boolean

Číst vypsaný modul ze souborového systému, kdykoli existuje. Užitečné pro ladění úpravou výsledku výpisu ze souborového systému.

server.deps

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

Zpracování řešení závislostí.

server.deps.external

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

Externalizace znamená, že Vite předá balíček přímo nativnímu Node. Externalizované závislosti nebudou aplikovány na transformátory a řešiče 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ů tak, jak jsou napsány v node_modules nebo specifikovány uvnitř 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 do deps.moduleDirectories. V podstatě Vitest vždy kontroluje cestu k souboru, nikoli skutečný název balíčku.

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

server.deps.inline

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

Vite zpracuje vložené moduly. To může být užitečné pro zpracování balíčků, které distribuují .js ve formátu ESM (který Node neumí zpracovat).

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

server.deps.fallbackCJS

Typ boolean
Výchozí: false

Pokud je závislost platným balíčkem ESM, pokuste se odhadnout verzi CJS na základě cesty. To může být užitečné, pokud má závislost špatný soubor ESM.

To může 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 ukládání souborů mezipaměti.

deps

Typ: { optimizer?, ... }

Zpracování řešení závislostí.

deps.optimizer

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

Povolit optimalizaci závislostí. Pokud máte mnoho testů, může to zlepšit jejich výkon.

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

Importování balíčků s mnoha importy je výpočetně náročné. Zabalení do jednoho souboru může ušetřit spoustu času.
Importování UI knihoven je výpočetně náročné, protože nejsou určeny k běhu uvnitř Node.js.
Vaše konfigurace alias je nyní respektována uvnitř zabalených balíčků.
Kód ve vašich testech běží blíže k tomu, jak běží v prohlížeči.

Mějte na paměti, že jsou baleny pouze balíčky v možnosti deps.optimizer?.[mode].include (některé pluginy to automaticky vyplňují, například Svelte). Více o dostupných možnostech si můžete přečíst 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 lze to konfigurovat pomocí transformMode.

Tyto možnosti 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šíří se tím 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 vynuceně znovu zabalte pomocí možnosti deps.optimizer?.[mode].force.

deps.optimizer.{mode}.enabled

Typ: boolean
Výchozí: false

Povolit optimalizaci závislostí.

deps.web

Typ: { transformAssets?, ... }

Možnosti, které se aplikují na externí soubory, když 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í.

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

deps.web.transformAssets

Typ: boolean
Výchozí: true

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

Tento modul bude mít výchozí export roven cestě k aktivu, pokud není zadán žádný dotaz.

WARNING

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

deps.web.transformCss

Typ: boolean
Výchozí: true

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

Pokud jsou soubory CSS 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 pooly vmThreads a vmForks.

deps.web.transformGlobPattern

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

Regulární výraz pro shodu s externími soubory, 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 asset a odpovídající možnost není zakázána.

WARNING

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

deps.interopDefault

Typ: boolean
Výchozí: true

Interpretovat 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, když je balíček importován pomocí syntaxe import namísto require. Při importu takových závislostí v prostředí Node pomocí pojmenovaných exportů uvidíte tuto chybu:

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 vašeho 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 problému, a proto 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 toho, co mockujete, odpovídá jedné z hodnot moduleDirectories, Vitest se pokusí vyřešit mock hledáním složky __mocks__ v kořeni projektu.

Tato možnost také ovlivní, zda se soubor považuje za modul při externalizaci závislostí. Ve výchozím nastavení Vitest importuje externí moduly pomocí nativního Node.js, čímž obchází krok transformace Vite.

Nastavení této možnosti přepíše výchozí hodnotu. Pokud si přejete stále prohledávat node_modules pro balíčky, zahrňte ji společně 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 testovacímu runneru. Toto je pokročilá funkce a měla by být používána s runnery vlastních 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)']

Zahrnout globy pro soubory benchmark testů

benchmark.exclude

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

Vyloučit globy pro soubory benchmark testů

benchmark.includeSource

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

Zahrnout globy pro soubory benchmark testů uvnitř zdrojového kódu. Tato možnost je podobná includeSource.

Pokud je definováno, 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 názvů vestavěných reportérů, instancí reportérů a/nebo cest k vlastním reportérům.

benchmark.outputFile

Zastaralé ve prospěch benchmark.outputJson.

benchmark.outputJson

Typ: string | undefined
Výchozí: undefined

Cesta k souboru pro uložení výsledku benchmarku, který lze později použít pro možnost --compare.

Například:

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

# změnit větev a porovnat s hlavní
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 }>

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

WARNING

Vitest používá Vite SSR primitiva pro spouštění testů, což má určité úskalí.

Aliases ovlivňují pouze moduly importované přímo klíčovým slovem import modulem, který je vložen (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), možná budete chtít aliasovat skutečné balíčky node_modules namísto toho, aby to fungovalo pro externalizované závislosti. Jak Yarn, tak pnpm podporují aliasing pomocí předpony npm:.

globals

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

Ve výchozím nastavení Vitest neposkytuje globální API z důvodu explicitnosti. Pokud dáváte přednost použití API globálně jako Jest, můžete zadat možnost --globals do CLI nebo přidat globals: true do konfigurace.

import { defineConfig } from 'vitest/config';

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

Pro správnou funkci TypeScriptu s globálními API přidejte vitest/globals do pole types ve vašem tsconfig.json

json

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

Pokud jste předefinovali své typeRoots pro zahrnutí více typů do vaší kompilace, budete muset přidat zpět node_modules, aby byl vitest/globals zjistitelný.

json

{
  "compilerOptions": {
    "typeRoots": ["./types", "./node_modules/@types", "./node_modules"],
    "types": ["vitest/globals"]
  }
}

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

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

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

environment

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

Prostředí, které bude použito pro testování. Výchozí prostředí ve Vitestu je prostředí Node.js. Pokud vytváříte webovou aplikaci, můžete použít prostředí podobné prohlížeči buď pomocí jsdom nebo happy-dom.

Pokud vytváříte edge funkce, můžete použít prostředí edge-runtime.

TIP

Můžete také použít režim prohlížeče pro spouštění integračních nebo jednotkových testů v prohlížeči bez mockování prostředí.

Přidáním docblocku nebo komentáře @vitest-environment na začátek souboru můžete určit jiné prostředí, které se má použít pro všechny testy v daném souboru:

Docblock style:

/**
 * @vitest-environment jsdom
 */

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

Comment style:

// @vitest-environment happy-dom

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

For compatibility with Jest, there is also a @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, vaše testy se spustí v tomto pořadí: node, jsdom, happy-dom, edge-runtime, vlastní prostředí. To znamená, že každý test se stejným prostředím je seskupen, ale stále běží sekvenčně.

Od verze 0.23.0 můžete také definovat vlastní prostředí. Pokud je použito nevýchozí prostředí, Vitest se pokusí načíst balíček vitest-environment-${name}. Tento balíček by měl exportovat objekt, který odpovídá rozhraní Environment:

import type { Environment } from 'vitest';

export default <Environment>{
  name: 'custom',
  transformMode: 'ssr',
  setup() {
    // vlastní nastavení
    return {
      teardown() {
        // voláno po spuštění všech testů s tímto prostředím
      },
    };
  },
};

Vitest také zpřístupňuje builtinEnvironments prostřednictvím vstupního bodu vitest/environments, pro případ, že byste jej chtěli pouze rozšířit. Více o rozšíření prostředí si můžete přečíst v našem průvodci.

TIP

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

json

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

environmentOptions

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

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 jej používáte jako testovací prostředí.

environmentMatchGlobs

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

ZASTARALÉ

Toto API bylo označeno jako zastaralé ve Vitestu 3. Místo toho použijte projekty k definování různých konfigurací.

export default defineConfig({
  test: {
    environmentMatchGlobs: [ 
      ['./*.jsdom.test.ts', 'jsdom'], 
    ], 
    projects: [ 
      { 
        extends: true, 
        test: { 
          environment: 'jsdom', 
        }, 
      }, 
    ], 
  },
})

Automaticky přiřadit prostředí na základě globů. Bude použita první shoda.

Například:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    environmentMatchGlobs: [
      // všechny testy v tests/dom poběží v jsdom
      ['tests/dom/**', 'jsdom'],
      // všechny testy v tests/ s .edge.test.ts poběží v edge-runtime
      ['**/*.edge.test.ts', 'edge-runtime'],
      // ...
    ],
  },
});

poolMatchGlobs

Typ: [string, 'threads' | 'forks' | 'vmThreads' | 'vmForks' | 'typescript'][]
Výchozí: []

ZASTARALÉ

Toto API bylo označeno jako zastaralé ve Vitestu 3. Místo toho použijte projekty k definování různých konfigurací:

export default defineConfig({
  test: {
    poolMatchGlobs: [ 
      ['./*.threads.test.ts', 'threads'], 
    ], 
    projects: [ 
      { 
        test: { 
          extends: true, 
          pool: 'threads', 
        }, 
      }, 
    ], 
  },
})

Automaticky přiřadit pool, ve kterém se budou spouštět testy, na základě globů. Bude použita první shoda.

Například:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolMatchGlobs: [
      // všechny testy v adresáři "worker-specific" poběží uvnitř workeru, jako byste pro ně povolili `--pool=threads`,
      ['**/tests/worker-specific/**', 'threads'],
      // spustit všechny testy v adresáři "browser" ve skutečném prohlížeči
      ['**/tests/browser/**', 'browser'],
      // všechny ostatní testy poběží na základě možností "browser.enabled" a "threads" options, if you didn't specify other globs
      // ...
    ],
  },
});

update*

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

Aktualizovat soubory snímků. Tím se aktualizují všechny změněné snímky a smažou zastaralé.

watch*

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

Povolit režim sledování

V interaktivních prostředích je to výchozí nastavení, pokud není explicitně zadáno --run.

V CI nebo při spuštění z neinteraktivního shellu režim "watch" není výchozí, ale lze jej explicitně povolit tímto příznakem.

watchTriggerPatterns 3.2.0+ *

Typ: WatcherTriggerPattern[]

Vitest znovu spouští testy na základě grafu modulů, který je vytvořen statickými a dynamickými příkazy import. Nicméně, pokud čtete ze souborového systému nebo načítáte z proxy, Vitest tyto závislosti nedokáže detekovat.

Pro správné opětovné spuštění těchto testů můžete definovat vzor regulárního výrazu a funkci, která vrátí seznam testovacích souborů ke spuštění.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    watchTriggerPatterns: [
      {
        pattern: /^src\/(mailers|templates)\/(.*)\.(ts|html|txt)$/,
        testToRun: (id, match) => {
          // relativně k hodnotě root
          return `./api/tests/mailers/${match[2]}.test.ts`;
        },
      },
    ],
  },
});

WARNING

Vrácené soubory by měly být buď absolutní, nebo relativní ke kořeni. Všimněte si, že se jedná o globální možnost a nelze ji použít uvnitř konfigurací projektu.

root

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

Kořen 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šťování testů, pokud váš kořen zahrnuje celý projekt.

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 reportéra, řetězec pro výběr vestavěných reportérů nebo cesta k vlastní implementaci (např. './path/to/reporter.ts', '@scope/reporter').

outputFile*

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

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

pool*

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

Pool použitý pro spouštění testů.

threads*

Povolit vícevláknové zpracování pomocí tinypool (lehká odnož Piscina). Při použití vláken nemůžete používat API pro práci s procesy, jako je process.chdir(). Některé knihovny napsané v nativních jazycích, jako Prisma, bcrypt a canvas, mají problémy při běhu ve více vláknech a způsobují segfaulty. V těchto případech se doporučuje použít místo toho pool forks.

forks*

Podobně jako pool threads, ale používá child_process místo worker_threads přes 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 v poolu forks k dispozici.

vmThreads*

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

To zrychluje spouštění testů, ale modul VM je nestabilní při spouštění ESM kódu. Vaše testy budou docházet k úniku paměti – pro řešení tohoto problému zvažte ruční úpravu hodnoty poolOptions.vmThreads.memoryLimit.

WARNING

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

Globální proměnné v nativních modulech, například (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 jakákoli chyba, kterou vyvolají tyto nativní moduly, bude 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í modulů ES 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 sandboxovaném prostředí.

Mějte prosím na paměti tyto problémy při používání této možnosti. Tým Vitestu nemůže žádný z těchto problémů vyřešit z naší strany.

vmForks*

Podobně jako pool vmThreads, ale používá child_process místo worker_threads přes 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 v poolu vmForks k dispozici. Mějte prosím na paměti, že tento pool má stejná úskalí uvedená v vmThreads.

poolOptions*

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

poolOptions.threads

Možnosti pro pool threads.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      threads: {
        // Možnosti související s vlákny zde
      },
    },
  },
});

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í: false

Spustit všechny testy se stejným prostředím v jednom pracovním vlákně. Tím se zakáže vestavěná izolace modulů (váš zdrojový kód nebo kód vložený bude stále znovu vyhodnocován pro každý test), ale může to zlepšit výkon testů.

WARNING

Přestože tato možnost vynutí spouštění testů jeden po druhém, liší se od Jestova --runInBand. Vitest používá workery nejen pro paralelní spouštění testů, ale také pro 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 různé problémy, pokud se spoléháte na globální stav (což obvykle dělají frontendové frameworky) nebo váš kód spoléhá na to, že prostředí je definováno samostatně pro každý test. Může to však výrazně zrychlit vaše testy (až 3x rychleji), které se nutně nespoléhají na globální stav nebo jej mohou snadno obejít.

poolOptions.threads.useAtomics*

Typ: boolean
Výchozí: false

Použít Atomics pro 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

Type: boolean
Default: true

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

poolOptions.threads.execArgv*

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

Předat dodatečné argumenty node ve vláknech. Další informace naleznete v Command-line API | Node.js.

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: {
        // Možnosti související s forky zde
      },
    },
  },
});

poolOptions.forks.maxForks*

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

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

poolOptions.forks.minForks*

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

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

poolOptions.forks.isolate

Typ: boolean
Výchozí: true

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

poolOptions.forks.singleFork

Typ: boolean
Výchozí: false

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

WARNING

Přestože tato možnost vynutí spouštění testů jeden po druhém, liší se od Jestova --runInBand. Vitest používá podřízené procesy nejen pro paralelní spouštění testů, ale také pro 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.

poolOptions.forks.execArgv*

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

Předat dodatečné argumenty procesu node v podřízených procesech. Další informace naleznete v Command-line API | Node.js.

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: {
        // Možnosti související s VM vlákny zde
      },
    },
  },
});

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í: 1 / CPU Cores

Určuje limit paměti pro workery před jejich recyklací. Tato hodnota silně závisí na vašem prostředí, takže je lepší ji specifikovat ručně, namísto spoléhání se na výchozí.

TIP

Implementace je založena na Jestově workerIdleMemoryLimit.

Limit lze specifikovat několika různými způsoby. Výsledek je vždy zaokrouhlen dolů pomocí Math.floor na celočíselnou hodnotu:

<= 1 - Hodnota je považována za 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 jde o pevnou bajtovou hodnotu. 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% - Jak je uvedeno 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

Procentuální limit paměti nefunguje na Linux CircleCI pracovních procesech kvůli nesprávně hlášené systémové paměti.

poolOptions.vmThreads.useAtomics*

Typ: boolean
Výchozí: false

Použít Atomics pro 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í: []

Předat dodatečné argumenty procesu node v kontextu VM. Další informace naleznete v Command-line API | Node.js.

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: {
        // Možnosti související s VM forky zde
      },
    },
  },
});

poolOptions.vmForks.maxForks*

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

Maximální počet nebo procento forků. 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 forků. Můžete také použít proměnnou prostředí VITEST_MIN_FORKS.

poolOptions.vmForks.memoryLimit*

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

Určuje limit paměti pro workery před jejich recyklací. Tato hodnota silně závisí na vašem prostředí, takže je lepší ji specifikovat ručně, než se spoléhat na výchozí. Způsob výpočtu hodnoty je popsán v poolOptions.vmThreads.memoryLimit.

poolOptions.vmForks.execArgv*

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

Předat dodatečné argumenty procesu node v kontextu VM. Další informace naleznete v Command-line API | Node.js.

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í: true
CLI: --no-file-parallelism, --fileParallelism=false

Mají se všechny testovací soubory spouštět paralelně. Nastavení na false přepíše možnosti maxWorkers a minWorkers na 1.

TIP

Tato možnost neovlivňuje testy běžící ve stejném souboru. Pokud je chcete spouštět paralelně, použijte možnost concurrent na describe nebo přes konfiguraci.

maxWorkers*

Typ: number | string

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

minWorkers*

Typ: 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

Typ: 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. Použijte 0 pro úplné zakázání časového limitu.

hookTimeout

Typ: 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. Použijte 0 pro úplné zakázání časového limitu.

teardownTimeout*

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

Výchozí časový limit pro čekání na ukončení při vypnutí Vitestu, v milisekundách.

silent*

Typ: boolean | 'passed-only'
Výchozí: false
CLI: --silent, --silent=false

Potlačit výstup konzole z testů.

Použijte 'passed-only' pro zobrazení logů pouze z neúspěšných testů. Logy z neúspěšných testů se tisknou po dokončení testu.

setupFiles

Typ: string | string[]

Cesta k souborům nastavení. Budou spuštěny před každým testovacím souborem.

INFO

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

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

TIP

Upozorňujeme, že pokud spouštíte --isolate=false, tento soubor nastavení bude spuštěn ve stejném globálním rozsahu vícekrát. To znamená, že přistupujete ke stejnému globálnímu objektu před každým testem, takže se ujistěte, že neděláte zbytečné opakování.

For example, you may rely on a global variable:

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

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

// háčky se resetují před každou sadou
afterEach(() => {
  cleanup();
});

globalThis.resetBeforeEachTest = true;

provide 2.1.0+

Typ: Partial<ProvidedContext>

Definujte hodnoty, ke kterým lze přistupovat uvnitř vašich testů pomocí metody inject.

vitest.config.jsapi.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 definici typu ProvidedContext pro typově bezpečný přístup:

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

// označte tento soubor jako modul, aby rozšíření fungovalo správně
export {};

globalSetup

Typ: string | string[]

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

Soubor globálního nastavení může buď exportovat funkce s názvem setup a teardown, nebo default funkci, která vrací funkci teardown (příklad).

INFO

Je možné mít více souborů globalSetup. Setup a teardown se provádějí sekvenčně, a teardown v opačném pořadí.

WARNING

Globální nastavení se spustí pouze v případě, že běží alespoň jeden test. To znamená, že globální nastavení se může začít spouštět v režimu sledování poté, co je testovací soubor změněn (testovací soubor počká na dokončení globálního nastavení před spuštěním).

Mějte na paměti, že globální nastavení běží v jiném globálním rozsahu, takže vaše testy nemají přístup k proměnným zde definovaným. Můžete však předávat serializovatelná data testům pomocí metody provide:

example.test.jsglobalSetup.ts 3.0.0+ globalSetup.ts 2.0.0+

import { inject } from 'vitest';

inject('wsPort') === 3000;

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

export default function setup(project: TestProject) {
  project.provide('wsPort', 3000);
}

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

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

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

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

Od Vitestu 3 můžete definovat vlastní funkci zpětného volání, která se zavolá, když Vitest znovu spustí testy. Pokud je funkce asynchronní, runner počká na její dokončení před spuštěním testů. Upozorňujeme, že nemůžete destrukturovat project jako { onTestsRerun }, protože se spoléhá na kontext.

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

export default function setup(project: TestProject) {
  project.onTestsRerun(async () => {
    await restartDb();
  });
}

forceRerunTriggers*

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

Glob vzor pro cesty k souborům, které spustí opětovné spuštění celé sady. Ve spojení s argumentem --changed spustí celou testovací sadu, pokud je spouštěč nalezen v git diffu.

Užitečné, pokud testujete spouštění CLI příkazů, protože Vite nemůže sestavit graf modulů:

test('execute a script', async () => {
  // Vitest nemůže tento test znovu spustit, 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 sběr pokrytí můžete použít v8, istanbul nebo vlastní řešení pokrytí.

Možnosti pokrytí můžete zadávat do 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 specifikovat --coverage.enabled. V takovém případě nezadávejte jedinou možnost --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

Povoluje sběr pokrytí. Lze přepsat pomocí možnosti 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ů zahrnutých do pokrytí jako glob vzory.

coverage.extension

Typ: string | string[]
Výchozí: ['.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í:

[
  '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ů vyloučených z pokrytí jako glob vzory.

Tato možnost přepíše 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 pro testovací soubory do coverage.exclude. Není možné zobrazit pokrytí testovacích souborů.

coverage.all

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

Zda zahrnout všechny soubory, včetně netestovaných, do zprávy.

coverage.clean

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

Vyčistit 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

Vyčistit zprávu o pokrytí při opětovném spuštění ve sledovacím režimu. Nastavte na false pro zachování výsledků pokrytí z předchozího spuštění v režimu sledování.

coverage.reportsDirectory

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

WARNING

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

Adresář pro zápis zprávy o pokrytí.

Pro náhled zprávy o pokrytí ve výstupu HTML reportéru musí být tato možnost nastavena jako podadresář adresáře HTML reportu (například ./html/coverage).

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éři pokrytí k použití. 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í. Další informace naleznete v Průvodci - Vlastní reportér pokrytí.

{
  reporter: [
    // Zadejte reportér pomocí názvu balíčku NPM
    '@vitest/custom-coverage-reporter',
    ['@vitest/custom-coverage-reporter', { someOption: true }],

    // Zadejte reportér pomocí lokální cesty
    '/absolute/path/to/custom-reporter.cjs',
    ['/absolute/path/to/custom-reporter.cjs', { someOption: true }],
  ];
}

Zprávu o pokrytí si můžete prohlédnout v Vitest UI. Další podrobnosti naleznete v Vitest UI Coverage.

coverage.reportOnFailure

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

Generovat 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írat pokrytí souborů mimo kořen projektu.

coverage.excludeAfterRemap 2.1.0+

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

Znovu aplikovat vyloučení poté, co bylo pokrytí přemapováno na původní zdroje. To je užitečné, když jsou vaše zdrojové soubory transpilovány a mohou obsahovat zdrojové mapy souborů, které nejsou zdrojové.

Tuto možnost použijte, když se ve zprávě objevují soubory, i když odpovídají vašim vzorům coverage.exclude.

coverage.skipFull

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

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

coverage.thresholds

Možnosti pro prahové hodnoty pokrytí.

Pokud je prahová hodnota nastavena na kladné číslo, bude interpretována jako minimální požadované procento pokrytí. Například nastavení prahové hodnoty řádků na 90 znamená, že musí být pokryto 90 % řádků.

Pokud je prahová hodnota nastavena na záporné číslo, bude považována za maximální povolený počet nepokrytých položek. Například nastavení prahové hodnoty řádků na -10 znamená, že nesmí být nepokryto více než 10 řádků.

{
  coverage: {
    thresholds: {
      // Vyžaduje 90% pokrytí funkcí
      functions: 90,

      // Vyžaduje, aby nebylo nepokryto více než 10 řádků
      lines: -10,
    }
  }
}

coverage.thresholds.lines

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

Globální práh pro řádky.

coverage.thresholds.functions

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

Globální práh pro funkce.

coverage.thresholds.branches

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

Globální práh pro větve.

coverage.thresholds.statements

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

Globální práh pro příkazy.

coverage.thresholds.perFile

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

Kontrolovat prahové hodnoty pro každý soubor.

coverage.thresholds.autoUpdate

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

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

coverage.thresholds.100

Typ: boolean
Výchozí: 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í: undefined
Dostupné pro poskytovatele: 'v8' | 'istanbul'

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

POZNÁMKA

Vitest počítá všechny soubory, včetně těch odpovídajících glob vzorům, do globálních prahových hodnot pokrytí. To se liší od chování Jesta.

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

      // Prahové hodnoty pro odpovídající glob vzor
      'src/utils/**.ts': {
        statements: 95,
        functions: 90,
        branches: 85,
        lines: 80,
      },

      // Soubory odpovídající tomuto vzoru budou mít nastaveny pouze prahové hodnoty řádků.
      // Globální prahové hodnoty se nedědí.
      '**/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 odpovídající glob vzor
      'src/utils/**.ts': { 100: true },
      '**/math.ts': { 100: true }
    }
  }
}

coverage.ignoreEmptyLines

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

Ignorovat prázdné řádky, komentáře a jiný kód, který se nespouští za běhu, např. typy Typescriptu. Vyžaduje experimentalAstAwareRemapping: false.

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

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

import { defineConfig } from 'vitest/config';

export default defineConfig({
  esbuild: {
    // Transpilovat všechny soubory pomocí ESBuild pro odstranění komentářů z pokrytí kódu.
    // Vyžadováno pro správnou funkci `test.coverage.ignoreEmptyLines`:"
    include: ['**/*.js', '**/*.jsx', '**/*.mjs', '**/*.ts', '**/*.tsx'],
  },
  test: {
    coverage: {
      provider: 'v8',
      ignoreEmptyLines: true,
    },
  },
});

coverage.experimentalAstAwareRemapping

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

Přemapovat pokrytí s experimentální analýzou založenou na AST. Poskytuje přesnější výsledky ve srovnání s výchozím režimem.

coverage.ignoreClassMethods

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

Nastavte jako pole názvů metod tříd, které se mají ignorovat pro pokrytí. Další informace 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'
CLI: --coverage.watermarks.statements=50,80, --coverage.watermarks.branches=50,80

Vodoznaky pro příkazy, řádky, větve a funkce. Další informace naleznete v dokumentaci istanbul.

coverage.processingConcurrency

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

Limit souběžnosti použitý 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 modulu vlastního poskytovatele pokrytí. Další informace naleznete v Průvodci - Vlastní poskytovatel pokrytí.

testNamePattern*

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

Spustit testy s plnými názvy odpovídajícími vzoru. Pokud do této vlastnosti přidáte OnlyRunThis, testy, které neobsahují slovo OnlyRunThis v názvu testu, budou přeskočeny.

import { expect, test } from 'vitest';

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

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

open*

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

Otevřít Vitest UI (WIP)

api

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

Naslouchat portu a obsluhovat API. Pokud je nastaveno na true, výchozí port je 51204.

browser experimentální

Výchozí: { enabled: false }
CLI: --browser=<name>, --browser.name=chrome --browser.headless

Konfigurace pro spouštění testů v prohlížeči. Prosím, viz článek "Browser Config Reference".

WARNING

Toto je experimentální funkce. Změny, které porušují zpětnou kompatibilitu, nemusí dodržovat SemVer, proto prosím při jejím používání zafixujte verzi Vitestu.

clearMocks

Typ: boolean
Výchozí: false

Před každým testem zavolá .mockClear() na všechny špiony. Tím se vymaže historie mocků, aniž by to ovlivnilo implementace mocků.

mockReset

Typ: boolean
Výchozí: false

Před každým testem zavolá .mockReset() na všechny špiony. Tím se vymaže historie mocků a každá implementace se resetuje na původní.

restoreMocks

Typ: boolean
Výchozí: false

Před každým testem zavolá .mockRestore() na všechny špiony. Tím se vymaže historie mocků, obnoví se každá implementace do původního stavu a obnoví se původní deskriptory špehovaných objektů.

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é v rámci 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žít SSR transformační pipeline pro všechny moduly uvnitř specifikovaných testů.
Vite pluginy obdrží příznak ssr: true při zpracování těchto souborů.

testTransformMode.web

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

Nejprve provede normální transformační pipeline (zaměřenou na prohlížeč), 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átu pro testování snímků. Tyto možnosti jsou předány do pretty-format.

TIP

Mějte na paměti, že pole plugins na tomto objektu bude ignorováno.

Pokud potřebujete rozšířit serializátor snímků pomocí pluginů pretty-format, použijte API expect.addSnapshotSerializer nebo možnost snapshotSerializers.

snapshotSerializers*

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

Seznam cest k modulům serializátorů snímků pro testování snímků, užitečné, pokud chcete přidat vlastní serializátory snímků. Další informace naleznete v Vlastní serializátor.

resolveSnapshotPath*

Typ: (testPath: string, snapExtension: string, context: { config: SerializedConfig }) => string
Výchozí: ukládá soubory snímků do adresáře __snapshots__

Přepíše výchozí cestu k snímku. Například pro uložení snímků 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

Povolit testy a sady, které jsou označeny jako "only".

dangerouslyIgnoreUnhandledErrors*

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

Ignorovat jakékoli neošetřené chyby, které se vyskytnou.

passWithNoTests*

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

Vitest neselže, pokud nebudou nalezeny žádné testy.

logHeapUsage

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

Zobrazit využití haldy 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, soubory CSS budou nahrazeny prázdnými řetězci, aby se obešlo následné zpracování. CSS moduly vrátí proxy, aby neovlivnily běhové prostředí.

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 pipeline Vite.

TIP

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

css.exclude

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

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

css.modules

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

css.modules.classNameStrategy

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

Pokud se rozhodnete zpracovávat soubory CSS, můžete nakonfigurovat, zda by názvy tříd uvnitř modulů CSS měly mít omezený rozsah. 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 snímků.
scoped: názvy tříd budou generovány jako obvykle, s respektováním metody css.modules.generateScopedName, pokud ji máte a je povoleno zpracování CSS. 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, čímž obchází zpracování CSS modulů. Pokud se spoléháte na vlastnosti CSS 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

Počet testů, které se mohou spouštět současně, označených test.concurrent.

Testy nad tímto limitem budou zařazeny do fronty a spustí se, jakmile se uvolní volný slot.

cache*

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

Tuto možnost použijte, pokud chcete zakázat funkci mezipaměti. V současné době Vitest ukládá výsledky testů do mezipaměti, aby se nejprve spustily delší a neúspěšné testy.

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?, groupOrder }

Možnosti pro řazení testů.

Možnosti sekvence můžete poskytnout CLI s tečkovou notací:

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

sequence.sequencer*

Typ: TestSequencerConstructor
Výchozí: BaseSequencer

Vlastní třída, která definuje metody pro sharding a řazení. Můžete rozšířit BaseSequencer z vitest/node, pokud potřebujete předefinovat pouze jednu z metod sort a shard, ale obě musí existovat.

Sharding probíhá před řazením a pouze v případě, že je zadána možnost --shard.

Pokud je zadáno sequencer.groupOrder, sekvencer bude volán jednou pro každou skupinu a pool.

groupOrder 3.2.0+

Typ: number
Výchozí: 0

Řídí pořadí, ve kterém tento projekt spouští své testy při použití více projektů.

Projekty se stejným číslem pořadí skupiny se spustí společně a skupiny se spouštějí od nejnižšího po nejvyšší.
Pokud tuto možnost nenastavíte, všechny projekty se spustí paralelně.
Pokud několik projektů používá stejné pořadí skupiny, spustí se současně.

Toto nastavení ovlivňuje pouze pořadí, ve kterém se projekty spouštějí, nikoli pořadí testů v rámci projektu. Pro řízení izolace testů nebo pořadí testů v rámci projektu použijte možnosti isolate a sequence.sequencer.

Příklad

Zvažte tento příklad:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    projects: [
      {
        test: {
          name: 'slow',
          sequence: {
            groupOrder: 0,
          },
        },
      },
      {
        test: {
          name: 'fast',
          sequence: {
            groupOrder: 0,
          },
        },
      },
      {
        test: {
          name: 'flaky',
          sequence: {
            groupOrder: 1,
          },
        },
      },
    ],
  },
});

Testy v těchto projektech se spustí v tomto pořadí:

 0. slow  |
          |> běží společně
 0. fast  |

 1. flaky |> běží po slow a fast samotné

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 náhodně, můžete to povolit touto možností nebo argumentem CLI --sequence.shuffle.

Vitest obvykle používá mezipaměť k řazení testů, takže dlouho běžící testy začínají dříve – to zrychluje spouštění testů. Pokud se vaše soubory a testy budou spouštět v náhodném pořadí, ztratíte toto zlepšení výkonu, ale může to být užitečné pro sledování testů, které náhodně závisí na jiném, dříve spuštěném testu.

sequence.shuffle.files

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

Zda soubory náhodně seřadit, mějte na paměti, že dlouho běžící testy nezačnou dříve, pokud tuto možnost povolíte.

sequence.shuffle.tests

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

Zda náhodně seřadit testy.

sequence.concurrent

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

Pokud chcete, aby se testy spouštěly paralelně, můžete to povolit touto možností nebo argumentem CLI --sequence.concurrent.

sequence.seed*

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

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

sequence.hooks

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

Mění pořadí, ve kterém se spouštějí háčky.

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

TIP

Tato možnost neovlivňuje onTestFinished. Vždy se volá v opačném pořadí.

sequence.setupFiles

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

Mění pořadí, ve kterém se spouštějí soubory nastavení.

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

typecheck

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

typecheck.enabled

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

Povolit kontrolu typů souběžně s vašimi běžnými testy.

typecheck.only

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

Spustit pouze testy kontroly typů, když 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

Jaké nástroje použít pro kontrolu typů. Vitest spustí proces s určitými parametry pro snadnější parsování, v závislosti na typu. Kontrolor by měl implementovat stejný výstupní formát jako tsc.

Pro použití kontroloru typů musíte mít nainstalovaný balíček:

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

Můžete také předat 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é 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 vzor pro soubory, které by neměly být považovány za testovací soubory.

typecheck.allowJs

Typ: boolean
Výchozí: false

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

typecheck.ignoreSourceErrors

Typ: boolean
Výchozí: false

Nezpůsobovat selhání, pokud Vitest najde chyby mimo testovací soubory. To vám vůbec nezobrazí chyby, které nejsou testovací.

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 tsconfigu, relativně ke kořeni projektu.

typecheck.spawnTimeout

Typ: number
Výchozí: 10_000

Minimální čas v milisekundách, který trvá spuštění kontroloru typů.

slowTestThreshold*

Typ: number
Výchozí: 300
CLI: --slow-test-threshold=<number>, --slowTestThreshold=<number>

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

chaiConfig

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

Ekvivalent Chai config.

chaiConfig.includeStack

Typ: boolean
Výchozí: false

Ovlivňuje, zda je do chybové zprávy Assertion zahrnuto trasování zásobníku. 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 AssertionErrors. false bude vždy false; true bude true, pokud aserce požadovala zobrazení rozdílu.

chaiConfig.truncateThreshold

Typ: number
Výchozí: 40

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

Tato konfigurační možnost ovlivňuje zkracování hodnot v názvech test.each a uvnitř chybové zprávy aserce.

bail

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

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

Ve výchozím nastavení Vitest spustí všechny vaše testovací případy, i když některé z nich selžou. To nemusí být žádoucí pro CI buildy, kde máte zájem pouze o 100% úspěšné buildy a chtěli byste zastavit provádění testů co nejdříve, když dojde k selhání testů. Možnost bail lze použít k urychlení běhů CI tím, že zabrání spouštění dalších testů, když dojde k selhání.

retry

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

Opakovat test specifikovaný početkrát, pokud selže.

onConsoleLog*

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

Vlastní handler 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 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

Aplikovat funkci filtrování na každý rámec každého 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ítnout všechny rámce z knihoven třetích stran.
      if (file.includes('node_modules')) {
        return false;
      }
    },
  },
});

diff

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

Objekt DiffOptions nebo cesta k modulu, který exportuje DiffOptions. Užitečné, pokud chcete přizpůsobit zobrazení rozdílů.

Například jako konfigurační objekt:

import { defineConfig } from 'vitest/config';
import c from 'picocolors';

export default defineConfig({
  test: {
    diff: {
      aIndicator: c.bold('--'),
      bIndicator: c.bold('++'),
      omitAnnotationLines: true,
    },
  },
});

Nebo jako modul:

vitest.config.jsvitest.diff.ts

import { defineConfig } from 'vitest/config';

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

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

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

diff.expand

Typ: boolean
Výchozí: true
CLI: --diff.expand=false

Rozbalit všechny společné řádky.

diff.truncateThreshold

Typ: number
Výchozí: 0
CLI: --diff.truncateThreshold=<path>

Maximální délka výsledku rozdílu, která se má zobrazit. Rozdíly 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'
CLI: --diff.truncateAnnotation=<annotation>

Anotace, která se zobrazí na konci výsledku rozdílu, 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 bezbarvý výstup.

diff.printBasicPrototype

Typ: boolean
Výchozí: false

Zobrazit základní prototyp Object a Array ve výstupu rozdílu.

diff.maxDepth

Typ: number
Výchozí: 20 (nebo 8 při porovnávání různých typů)

Omezit hloubku rekurze při tisku vnořených objektů.

fakeTimers

Typ: FakeTimerInstallOpts

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

fakeTimers.now

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

Nainstaluje falešné časovače se zadanou Unix epochou.

fakeTimers.toFake

Typ: ('setTimeout' | 'clearTimeout' | 'setImmediate' | 'clearImmediate' | 'setInterval' | 'clearInterval' | 'Date' | 'nextTick' | 'hrtime' | 'requestAnimationFrame' | 'cancelAnimationFrame' | 'requestIdleCallback' | 'cancelIdleCallback' | 'performance' | 'queueMicrotask')[]
Výchozí: vše dostupné globálně kromě nextTick a queueMicrotask

Pole s názvy globálních metod a API pro falšování.

Chcete-li mockovat pouze setTimeout() a nextTick(), zadejte tuto vlastnost jako ['setTimeout', 'nextTick'].

Mockování nextTick není podporováno při spouštění Vitestu v rámci node:child_process při použití --pool=forks. NodeJS interně používá process.nextTick v node:child_process a zamrzne, pokud je mockováno. Mockování nextTick je podporováno při spouštění Vitestu s --pool=threads.

fakeTimers.loopLimit

Typ: number
Výchozí: 10_000

Maximální počet časovačů, které se spustí při volání vi.runAllTimers().

fakeTimers.shouldAdvanceTime

Typ: boolean
Výchozí: false

Říká @sinonjs/fake-timers, aby automaticky inkrementoval mockovaný čas na základě skutečného posunu systémového času (např. mockovaný čas se inkrementuje o 20 ms za každých 20 ms změny ve skutečném systémovém čase).

fakeTimers.advanceTimeDelta

Typ: number
Výchozí: 20

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

fakeTimers.shouldClearNativeTimers

Typ: boolean
Výchozí: true

Říká falešným časovačům, aby vymazaly "nativní" (tj. nefalešné) časovače delegováním na jejich příslušné handlery. Pokud je 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*

ZASTARALÉ

Tato možnost je zastaralá a bude odstraněna v příští hlavní verzi. Místo toho použijte projects.

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

Cesta k souboru konfigurace pracovního prostoru relativně ke kořeni.

Od Vitestu 3 můžete také definovat pole pracovního prostoru v kořenové konfiguraci. Pokud je workspace definován v konfiguraci ručně, Vitest bude ignorovat soubor vitest.workspace v kořeni.

projects*

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

Pole projektů.

isolate

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

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

Zakázání této možnosti může zlepšit výkon, pokud váš kód nespoléhá na vedlejší efekty (což je obvykle pravda pro projekty s prostředím node).

TIP

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

includeTaskLocation

Typ: boolean
Výchozí: false

Zda má být vlastnost location zahrnuta, když Vitest API přijímá úkoly v reportérech. Pokud máte mnoho 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 používáte režim prohlížeče bez headless režimu
nebo používáte HTML reportér

TIP

Tato možnost nemá žádný vliv, pokud nepoužíváte vlastní kód, který se na ni spoléhá.

snapshotEnvironment

Typ: string

Cesta k vlastní implementaci prostředí snímků. To je užitečné, pokud spouštíte testy v prostředí, které nepodporuje Node.js API. Tato možnost nemá žádný vliv na prohlížečový runner.

Tento objekt by měl odpovídat rozhraní SnapshotEnvironment a slouží k řešení a čtení/zápisu souborů snímků:

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>;
}

Můžete rozšířit výchozí VitestSnapshotEnvironment z vstupního bodu vitest/snapshot, pokud potřebujete přepsat pouze část API.

WARNING

Toto je nízkoúrovňová možnost a měla by být použita pouze pro pokročilé případy, kdy nemáte přístup k výchozím Node.js API.

Pokud potřebujete pouze konfigurovat funkci snímků, použijte možnosti 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. Tím se zajistí, že žádný test neprojde náhodně.

TIP

Toto funguje pouze s Vitestovým expect. Pokud používáte assert nebo .should aserce, nebudou se počítat a váš test selže kvůli nedostatku expect asercí.

Hodnotu této možnosti můžete změnit voláním vi.setConfig({ expect: { requireAssertions: false } }). Konfigurace bude aplikována na každé následné volání expect, dokud nebude ručně zavoláno vi.resetConfig.

expect.poll

Globální konfigurační možnosti 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 miliseundách.

printConsoleTrace

Typ: boolean
Výchozí: false

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

attachmentsDir 3.2.0+

Typ: string
Výchozí: '.vitest-attachments'

Cesta k adresáři pro ukládání příloh vytvořených pomocí context.annotate relativně ke kořeni projektu.

Konfigurace Vitestu ​

include ​

exclude ​

includeSource ​

name ​

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* ​

watchTriggerPatterns 3.2.0+ * ​

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 ​

Konfigurace Vitestu

include

exclude

includeSource

name

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*

watchTriggerPatterns 3.2.0+ *

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