Konfiguracja Vitest

Aby utworzyć plik konfiguracyjny Vitest, zapoznaj się z przewodnikiem. Upewnij się, że rozumiesz, jak działa mechanizm rozwiązywania konfiguracji Vitest, zanim przejdziesz dalej.

WARNING

Wszystkie wymienione opcje znajdują się we właściwości test w konfiguracji:

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

TIP

Oprócz poniższych opcji możesz również użyć dowolnej opcji konfiguracyjnej z Vite. Na przykład define do definiowania zmiennych globalnych lub resolve.alias do definiowania aliasów.

Wszystkie opcje konfiguracyjne, które nie są obsługiwane w konfiguracji przestrzeni roboczej, są oznaczone *.

include

Typ: string[]
Domyślnie: ['**/*.{test,spec}.?(c|m)[jt]s?(x)']
CLI: vitest [...include], vitest **/*.test.js

Lista wzorców glob określających, które pliki mają być traktowane jako pliki testowe.

UWAGA

Podczas używania pokrycia, Vitest automatycznie dodaje wzorce include plików testowych do domyślnych wzorców exclude pokrycia. Zobacz coverage.exclude.

exclude

Typ: string[]
Domyślnie: ['**/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"

Lista wzorców glob, które mają być pominięte podczas wyszukiwania plików testowych.

WARNING

Ta opcja nie wpływa na pokrycie kodu. Jeśli chcesz wykluczyć określone pliki z raportu pokrycia, użyj coverage.exclude.

Jest to jedyna opcja, która nie nadpisuje konfiguracji, jeśli zostanie podana jako flaga CLI. Wszystkie wzorce glob dodane za pomocą flagi --exclude zostaną dołączone do konfiguracji w sekcji exclude.

includeSource

Typ: string[]
Domyślnie: []

Wzorce glob dla plików w kodzie źródłowym, które powinny być traktowane jako pliki testowe.

Po zdefiniowaniu, Vitest uruchomi wszystkie pasujące pliki zawierające import.meta.vitest.

server

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

Opcje serwera Vite-Node.

server.sourcemap

Typ: 'inline' | boolean
Domyślnie: 'inline'

Wstrzykuje mapę źródłową inline do modułów.

server.debug

Typ: { dumpModules?, loadDumppedModules? }

Opcje debugowania Vite-Node.

server.debug.dumpModules

Typ: boolean | string

Zapisuje przekształcony moduł do systemu plików. Przekazanie ciągu znaków spowoduje zapis do określonej ścieżki.

server.debug.loadDumppedModules

Typ: boolean

Wczytuje zapisany moduł z systemu plików, jeśli taki istnieje. Przydatne do debugowania poprzez modyfikację zrzutu z systemu plików.

server.deps

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

Konfiguracja rozwiązywania zależności.

server.deps.external

Typ: (string | RegExp)[]
Domyślnie: [/\/node_modules\//]

Eksternalizacja oznacza, że Vite pominie przetwarzanie pakietu i przekaże go bezpośrednio do natywnego Node. Eksternalizowane zależności nie będą przetwarzane przez transformatory i resolver Vite, dlatego nie obsługują HMR podczas przeładowania. Domyślnie wszystkie pakiety wewnątrz node_modules są eksternalizowane.

Te opcje obsługują nazwy pakietów tak, jak są zapisane w node_modules lub określone wewnątrz deps.moduleDirectories. Na przykład pakiet @company/some-name znajdujący się wewnątrz packages/some-name powinien być określony jako some-name, a packages powinno być zawarte w deps.moduleDirectories. Zasadniczo Vitest zawsze sprawdza ścieżkę do pliku, a nie rzeczywistą nazwę pakietu.

Jeśli używany jest regexp, Vitest wywołuje go na ścieżce do pliku, a nie na nazwie pakietu.

server.deps.inline

Typ: (string | RegExp)[] | true
Domyślnie: []

Vite przetworzy moduły oznaczone jako inline. Może to być przydatne w przypadku pakietów dostarczających pliki .js w formacie ESM, które nie są natywnie obsługiwane przez Node.

Jeśli true, każda zależność zostanie inlined. Wszystkie zależności określone w ssr.noExternal zostaną inlined domyślnie.

server.deps.fallbackCJS

Typ boolean
Domyślnie: false

Jeśli zależność jest prawidłowym pakietem ESM, spróbuj ustalić wersję CJS na podstawie ścieżki. Może to być przydatne, jeśli zależność ma nieprawidłowy plik ESM.

Może to potencjalnie spowodować pewne niezgodności, jeśli pakiet ma inną logikę w trybie ESM i CJS.

server.deps.cacheDir

Typ string
Domyślnie: 'node_modules/.vite'

Katalog do przechowywania plików cache.

deps

Typ: { optimizer?, ... }

Konfiguracja rozwiązywania zależności.

deps.optimizer

Typ: { ssr?, web? }
Zobacz również: Opcje Optymalizacji Zależności

Włącz optymalizację zależności. Jeśli masz dużo testów, może to poprawić ich wydajność.

Gdy Vitest napotka zewnętrzną bibliotekę zdefiniowaną w include, zostanie ona zbundlowana do pojedynczego pliku za pomocą esbuild i zaimportowana jako moduł. Jest to korzystne z kilku powodów:

Importowanie pakietów z dużą liczbą importów jest kosztowne. Spakowanie ich do jednego pliku pozwala zaoszczędzić czas.
Importowanie bibliotek UI jest kosztowne, ponieważ nie są one przeznaczone do uruchamiania wewnątrz Node.js.
Twoja konfiguracja alias jest teraz respektowana wewnątrz spakowanych pakietów.
Kod w testach jest wykonywany w sposób zbliżony do tego, jak działa w przeglądarce.

Należy pamiętać, że tylko pakiety zdefiniowane w deps.optimizer?.[mode].include są bundlowane (niektóre wtyczki robią to automatycznie, np. Svelte). Możesz przeczytać więcej o dostępnych opcjach w dokumentacji Vite (Vitest nie obsługuje opcji disable i noDiscovery). Domyślnie Vitest stosuje optimizer.web dla środowisk jsdom i happy-dom, a optimizer.ssr dla środowisk node i edge, ale można to skonfigurować za pomocą transformMode.

Te opcje dziedziczą również konfigurację optimizeDeps (dla środowiska web Vitest rozszerzy optimizeDeps, a dla ssr - ssr.optimizeDeps). Jeśli przedefiniujesz opcje include/exclude w deps.optimizer, zostaną one uwzględnione podczas optymalizacji zależności w trakcie uruchamiania testów. Vitest automatycznie usuwa te same opcje z include, jeśli znajdują się one również w exclude.

TIP

Edycja kodu w node_modules w celu debugowania nie będzie możliwa, ponieważ kod znajduje się w katalogu cacheDir lub test.cache.dir. Jeśli chcesz debugować za pomocą instrukcji console.log, edytuj go bezpośrednio lub wymuś ponowne spakowanie za pomocą opcji deps.optimizer?.[mode].force.

deps.optimizer.{mode}.enabled

Typ: boolean
Domyślnie: false

Włącz optymalizację zależności.

deps.web

Typ: { transformAssets?, ... }

Opcje, które są stosowane do zewnętrznych plików, gdy tryb transformacji jest ustawiony na web. Domyślnie jsdom i happy-dom używają trybu web, podczas gdy środowiska node i edge używają trybu transformacji ssr, więc te opcje nie będą miały wpływu na pliki wewnątrz tych środowisk.

Zazwyczaj pliki wewnątrz node_modules są eksternalizowane, ale te opcje wpływają również na pliki w server.deps.external.

deps.web.transformAssets

Typ: boolean
Domyślnie: true

Czy Vitest ma przetwarzać pliki zasobów (np. .png, .svg, .jpg) i rozwiązywać je w taki sam sposób, jak Vite w przeglądarce?

Ten moduł będzie miał domyślny eksport równy ścieżce do zasobu, jeśli nie określono zapytania.

WARNING

Obecnie ta opcja działa tylko z pulami vmThreads i vmForks.

deps.web.transformCss

Typ: boolean
Domyślnie: true

Czy Vitest ma przetwarzać pliki CSS (np. .css, .scss, .sass) i rozwiązywać je w taki sam sposób, jak Vite w przeglądarce?

Jeśli pliki CSS są wyłączone za pomocą opcji css, ta opcja po prostu wyciszy błędy ERR_UNKNOWN_FILE_EXTENSION.

WARNING

Obecnie ta opcja działa tylko z pulami vmThreads i vmForks.

deps.web.transformGlobPattern

Typ: RegExp | RegExp[]
Domyślnie: []

Wzorzec wyrażenia regularnego do dopasowywania zewnętrznych plików, które mają zostać przekształcone.

Domyślnie pliki wewnątrz node_modules są eksternalizowane i nie są przekształcane, chyba że jest to CSS lub zasób, a odpowiednia opcja nie jest wyłączona.

WARNING

Obecnie ta opcja działa tylko z pulami vmThreads i vmForks.

deps.interopDefault

Typ: boolean
Domyślnie: true

Traktuj domyślny eksport modułu CJS jako eksporty nazwane. Niektóre zależności zawierają tylko moduły CJS i nie używają eksportów nazwanych, które Node.js może statycznie analizować, gdy pakiet jest importowany za pomocą składni import zamiast require. Podczas importowania takich zależności w środowisku Node za pomocą eksportów nazwanych, zobaczysz ten błąd:

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 nie przeprowadza analizy statycznej i nie może wykryć problemu przed uruchomieniem kodu, dlatego ten błąd najprawdopodobniej pojawi się podczas uruchamiania testów, jeśli ta funkcja jest wyłączona:

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

Domyślnie Vitest zakłada, że używasz bundlera, aby to ominąć i nie zawiedzie, ale możesz wyłączyć to zachowanie ręcznie, jeśli twój kod nie jest przetwarzany.

deps.moduleDirectories

Typ: string[]
Domyślnie: ['node_modules']

Lista katalogów, które powinny być traktowane jako katalogi modułów. Ta opcja konfiguracyjna wpływa na działanie vi.mock: jeśli nie podano fabryki, a ścieżka mockowanego modułu pasuje do jednej z wartości moduleDirectories, Vitest spróbuje znaleźć mock, szukając folderu __mocks__ w korzeniu projektu.

Ta opcja wpływa również na to, czy dany plik ma być traktowany jako moduł podczas eksternalizacji zależności. Domyślnie Vitest importuje zewnętrzne moduły za pomocą natywnego Node.js, pomijając krok transformacji Vite.

Ustawienie tej opcji nadpisze wartość domyślną. Jeśli chcesz, aby przeszukiwane były również node_modules, dodaj je do listy wraz z innymi katalogami:

import { defineConfig } from 'vitest/config';

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

runner

Typ: VitestRunnerConstructor
Domyślnie: node, podczas uruchamiania testów, lub benchmark, podczas uruchamiania benchmarków

Ścieżka do niestandardowego środowiska uruchomieniowego testów. Jest to zaawansowana funkcja, która powinna być używana z niestandardowymi środowiskami uruchomieniowymi bibliotek. Możesz przeczytać o tym więcej w dokumentacji.

benchmark

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

Opcje używane podczas uruchamiania vitest bench.

benchmark.include

Typ: string[]
Domyślnie: ['**/*.{bench,benchmark}.?(c|m)[jt]s?(x)']

Wzorce glob plików benchmarków do uwzględnienia.

benchmark.exclude

Typ: string[]
Domyślnie: ['node_modules', 'dist', '.idea', '.git', '.cache']

Wzorce glob plików benchmarków do wykluczenia.

benchmark.includeSource

Typ: string[]
Domyślnie: []

Wzorce glob plików benchmarków w kodzie źródłowym do uwzględnienia. Ta opcja jest podobna do includeSource.

Po zdefiniowaniu, Vitest uruchomi wszystkie pasujące pliki zawierające import.meta.vitest.

benchmark.reporters

Typ: Arrayable<BenchmarkBuiltinReporters | Reporter>
Domyślnie: 'default'

Niestandardowy reporter wyników. Może zawierać jedną lub więcej wbudowanych nazw raportów, instancji reporterów i/lub ścieżek do niestandardowych reporterów.

benchmark.outputFile

Przestarzałe na rzecz benchmark.outputJson.

benchmark.outputJson

Typ: string | undefined
Domyślnie: undefined

Ścieżka pliku do zapisu wyniku benchmarku, który może być później użyty z opcją --compare.

Na przykład:

# zapisz wynik głównej gałęzi
git checkout main
vitest bench --outputJson main.json

# zmień gałąź i porównaj z główną
git checkout feature
vitest bench --compare main.json

benchmark.compare

Typ: string | undefined
Domyślnie: undefined

Ścieżka pliku do poprzedniego wyniku benchmarku, z którym mają być porównane bieżące wyniki.

alias

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

Definiuje niestandardowe aliasy używane podczas uruchamiania testów. Zostaną one scalone z aliasami zdefiniowanymi w resolve.alias.

WARNING

Vitest używa prymitywów Vite SSR do uruchamiania testów, co wiąże się z pewnymi ograniczeniami.

Aliasy wpływają tylko na moduły importowane bezpośrednio za pomocą słowa kluczowego import przez inlined moduł (cały kod źródłowy jest inlined domyślnie).
Vitest nie obsługuje aliasowania wywołań require.
Jeśli tworzysz alias dla zewnętrznej zależności (np. react -> preact), warto rozważyć utworzenie aliasu dla rzeczywistych pakietów w node_modules, aby zapewnić poprawne działanie dla eksternalizowanych zależności. Zarówno Yarn, jak i pnpm obsługują aliasowanie za pomocą prefiksu npm:.

globals

Typ: boolean
Domyślnie: false
CLI: --globals, --globals=false

Domyślnie vitest nie udostępnia globalnych API, aby wymusić jawność. Jeśli wolisz używać API globalnie, tak jak w Jest, możesz przekazać opcję --globals do CLI lub dodać globals: true do konfiguracji.

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

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

Aby zapewnić poprawne działanie TypeScript z globalnymi API, dodaj vitest/globals do pola types w pliku tsconfig.json.

json

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

Jeśli już używasz unplugin-auto-import w swoim projekcie, możesz również użyć go bezpośrednio do automatycznego importowania tych 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, // generate TypeScript declaration
    }),
  ],
});

environment

Typ: 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime' | string
Wartość domyślna: 'node'
CLI: --environment=<env>

Określa środowisko używane do uruchamiania testów. Domyślnym środowiskiem w Vitest jest Node.js. W przypadku testowania aplikacji internetowych można użyć środowiska emulującego przeglądarkę, takiego jak jsdom lub happy-dom. Do testowania funkcji Edge można wykorzystać środowisko edge-runtime.

TIP

Możesz również użyć Trybu przeglądarki do uruchamiania testów integracyjnych lub jednostkowych w przeglądarce bez naśladowania środowiska.

Można zdefiniować inne środowisko dla wszystkich testów w danym pliku, dodając docblock @vitest-environment lub komentarz na początku pliku:

Styl Docblock:

/**
 * @vitest-environment jsdom
 */

test('użyj jsdom w tym pliku testowym', () => {
  const element = document.createElement('div');
  expect(element).not.toBeNull();
});

Styl komentarza:

// @vitest-environment happy-dom

test('użyj happy-dom w tym pliku testowym', () => {
  const element = document.createElement('div');
  expect(element).not.toBeNull();
});

Dla zachowania kompatybilności z Jest, obsługiwany jest również @jest-environment:

/**
 * @jest-environment jsdom
 */

test('użyj jsdom w tym pliku testowym', () => {
  const element = document.createElement('div');
  expect(element).not.toBeNull();
});

Jeśli Vitest jest uruchamiany z flagą --isolate=false, testy będą uruchamiane w następującej kolejności: node, jsdom, happy-dom, edge-runtime, niestandardowe środowiska. Oznacza to, że testy z tym samym środowiskiem są grupowane, ale nadal wykonywane sekwencyjnie.

Od wersji 0.23.0 można definiować własne środowiska. Gdy używane jest środowisko inne niż wbudowane, Vitest próbuje załadować pakiet vitest-environment-${name}. Ten pakiet powinien eksportować obiekt o strukturze Environment:

import type { Environment } from 'vitest';

export default <Environment>{
  name: 'custom',
  transformMode: 'ssr',
  setup() {
    // niestandardowa konfiguracja
    return {
      teardown() {
        // wywoływane po uruchomieniu wszystkich testów z tym środowiskiem
      },
    };
  },
};

Vitest udostępnia również builtinEnvironments poprzez wpis vitest/environments, na wypadek gdybyś chciał go rozszerzyć. Więcej informacji o rozszerzaniu środowisk można znaleźć w naszym przewodniku.

TIP

Środowisko jsdom udostępnia zmienną globalną jsdom, która jest równa bieżącej instancji JSDOM. Jeśli chcesz, aby TypeScript ją rozpoznawał, możesz dodać vitest/jsdom do pliku tsconfig.json, gdy używasz tego środowiska:

json

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

environmentOptions

Typ: Record<'jsdom' | string, unknown>
Wartość domyślna: {}

Opcje przekazywane do metody setup bieżącego environment. Domyślnie można konfigurować tylko opcje JSDOM, jeśli jest on używany jako środowisko testowe.

environmentMatchGlobs

Typ: [string, EnvironmentName][]
Wartość domyślna: []

Automatycznie przypisuje środowisko na podstawie wzorców glob. Używane jest pierwsze dopasowanie.

Na przykład:

import { defineConfig } from 'vitest/config';

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

poolMatchGlobs

Typ: [string, 'threads' | 'forks' | 'vmThreads' | 'vmForks' | 'typescript'][]
Wartość domyślna: []

Automatycznie przypisuje pulę, w której testy będą uruchamiane, na podstawie wzorców glob. Używane jest pierwsze dopasowanie.

Na przykład:

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'],
      // all other tests will run based on "browser.enabled" and "threads" options, if you didn't specify other globs
      // ...
    ],
  },
});

update*

Typ: boolean
Wartość domyślna: false
CLI: -u, --update, --update=false

Aktualizuje pliki snapshotów. Powoduje to zaktualizowanie wszystkich zmienionych snapshotów i usunięcie przestarzałych.

watch*

Typ: boolean
Wartość domyślna: !process.env.CI
CLI: -w, --watch, --watch=false

Włącza tryb obserwacji (watch mode).

root

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

Katalog główny projektu.

dir

Typ: string
CLI: --dir=<path>
Domyślnie: taki sam jak root

Katalog bazowy do skanowania plików testowych. Możesz określić tę opcję, aby przyspieszyć wykrywanie testów, jeśli twój katalog główny obejmuje cały projekt.

reporters*

Typ: Reporter | Reporter[]
Wartość domyślna: 'default'
CLI: --reporter=<name>, --reporter=<name1> --reporter=<name2>

Własne reportery dla wyjścia. Reportery mogą być instancją Reportera, ciągiem znaków wybierającym wbudowane reportery lub ścieżką do niestandardowej implementacji (np. './path/to/reporter.ts', '@scope/reporter').

outputFile*

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

Zapisuje wyniki testów do pliku, gdy określono również opcję --reporter=json, --reporter=html lub --reporter=junit. Podając obiekt zamiast ciągu znaków, można zdefiniować indywidualne wyjścia podczas korzystania z wielu reporterów.

pool*

Typ: 'threads' | 'forks' | 'vmThreads' | 'vmForks'
Wartość domyślna: 'forks'
CLI: --pool=threads

Pula, w której uruchamiane są testy.

threads*

Włącza wielowątkowość za pomocą tinypool (lekkiego forka Piscina). Podczas korzystania z wątków nie można używać API związanych z procesami, takich jak process.chdir(). Niektóre biblioteki napisane w językach natywnych, takie jak Prisma, bcrypt i canvas, mogą mieć problemy podczas uruchamiania w wielu wątkach i powodować błędy segmentacji. W takich przypadkach zaleca się użycie puli forks.

forks*

Podobna do puli threads, ale używa child_process zamiast worker_threads za pośrednictwem tinypool. Komunikacja między testami a procesem głównym nie jest tak szybka jak w przypadku puli threads. API związane z procesami, takie jak process.chdir(), są dostępne w puli forks.

vmThreads*

Uruchamia testy za pomocą kontekstu VM (wewnątrz środowiska izolowanego) w puli threads.

Przyspiesza to uruchamianie testów, ale moduł VM jest niestabilny podczas uruchamiania kodu ESM. Testy mogą wyciekać pamięć - aby temu zapobiec, rozważ ręczną edycję wartości poolOptions.vmThreads.memoryLimit.

WARNING

Uruchamianie kodu w środowisku izolowanym ma pewne zalety (szybsze testy), ale wiąże się również z szeregiem wad.

Globale w modułach natywnych, takie jak (fs, path itp.), różnią się od globalnych obecnych w środowisku testowym. W rezultacie każdy błąd zgłoszony przez te moduły natywne będzie odwoływał się do innego konstruktora Error w porównaniu z tym używanym w kodzie:

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

Importowanie modułów ES przechowuje je w pamięci podręcznej na czas nieokreślony, co powoduje wycieki pamięci, jeśli masz dużo kontekstów (plików testowych). W Node.js nie ma API, które czyści tę pamięć podręczną.
Dostęp do globalnych trwa dłużej w środowisku izolowanym.

Należy pamiętać o tych problemach podczas korzystania z tej opcji. Zespół Vitest nie może naprawić żadnego z tych problemów po naszej stronie.

vmForks*

Podobna do puli vmThreads, ale używa child_process zamiast worker_threads za pośrednictwem tinypool. Komunikacja między testami a procesem głównym nie jest tak szybka jak w przypadku puli vmThreads. API związane z procesami, takie jak process.chdir(), są dostępne w puli vmForks. Należy pamiętać, że ta pula ma te same wady, co wymienione w vmThreads.

poolOptions*

Typ: Record<'threads' | 'forks' | 'vmThreads' | 'vmForks', {}>
Wartość domyślna: {}

poolOptions.threads

Opcje dla puli threads.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      threads: {
        // Opcje wątków
      },
    },
  },
});

poolOptions.threads.maxThreads*

Typ: number | string
Domyślnie: dostępne procesory

Maksymalna liczba lub procent wątków. Możesz również użyć zmiennej środowiskowej VITEST_MAX_THREADS.

poolOptions.threads.minThreads*

Typ: number | string
Domyślnie: dostępne procesory

Minimalna liczba lub procent wątków. Możesz również użyć zmiennej środowiskowej VITEST_MIN_THREADS.

poolOptions.threads.singleThread

Typ: boolean
Wartość domyślna: false

Uruchamia wszystkie testy z tym samym środowiskiem wewnątrz jednego wątku roboczego. Wyłącza to wbudowaną izolację modułów (kod źródłowy lub wstawiony nadal będzie ponownie oceniany dla każdego testu), ale może poprawić wydajność testów.

WARNING

Pomimo że ta opcja wymusza uruchamianie testów jeden po drugim, różni się ona od --runInBand Jesta. Vitest używa workerów nie tylko do równoległego uruchamiania testów, ale także do zapewnienia izolacji. Wyłączenie tej opcji spowoduje, że testy będą uruchamiane sekwencyjnie, ale w tym samym kontekście globalnym, więc musisz sam zapewnić izolację.

Może to powodować różnego rodzaju problemy, jeśli polegasz na stanie globalnym (frameworki frontendowe zazwyczaj tak robią) lub twój kod wymaga, aby środowisko było zdefiniowane oddzielnie dla każdego testu. Może to jednak znacznie przyspieszyć testy (nawet 3-krotnie), które nie polegają na stanie globalnym lub mogą go łatwo obejść.

poolOptions.threads.useAtomics*

Typ: boolean
Wartość domyślna: false

Używa Atomics do synchronizacji wątków.

Może to poprawić wydajność w niektórych przypadkach, ale może spowodować błąd segmentacji w starszych wersjach Node.

poolOptions.threads.isolate

Typ: boolean
Wartość domyślna: true

Izoluje środowisko dla każdego pliku testowego.

poolOptions.threads.execArgv*

Typ: string[]
Wartość domyślna: []

Przekazuje dodatkowe argumenty do node w wątkach. Zobacz Command-line API | Node.js aby uzyskać więcej informacji.

WARNING

Należy zachować ostrożność podczas używania, ponieważ niektóre opcje mogą spowodować awarię workera, np. --prof, --title. Zobacz https://github.com/nodejs/node/issues/41103.

poolOptions.forks

Opcje dla puli forks.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      forks: {
        // Opcje forków
      },
    },
  },
});

poolOptions.forks.maxForks*

Typ: number | string
Domyślnie: dostępne procesory

Maksymalna liczba lub procent forków.

poolOptions.forks.minForks*

Typ: number | string
Domyślnie: dostępne procesory

Minimalna liczba lub procent forków.

poolOptions.forks.isolate

Typ: boolean
Wartość domyślna: true

Izoluje środowisko dla każdego pliku testowego.

poolOptions.forks.singleFork

Typ: boolean
Wartość domyślna: false

Uruchamia wszystkie testy z tym samym środowiskiem wewnątrz jednego procesu potomnego. Wyłącza to wbudowaną izolację modułów (kod źródłowy lub wstawiony nadal będzie ponownie oceniany dla każdego testu), ale może poprawić wydajność testów.

WARNING

Pomimo że ta opcja wymusza uruchamianie testów jeden po drugim, różni się ona od --runInBand Jesta. Vitest używa procesów potomnych nie tylko do równoległego uruchamiania testów, ale także do zapewnienia izolacji. Wyłączenie tej opcji spowoduje, że testy będą uruchamiane sekwencyjnie, ale w tym samym kontekście globalnym, więc musisz sam zapewnić izolację.

poolOptions.forks.execArgv*

Typ: string[]
Wartość domyślna: []

Przekazuje dodatkowe argumenty do procesu node w procesach potomnych. Zobacz Command-line API | Node.js aby uzyskać więcej informacji.

WARNING

Należy zachować ostrożność podczas używania, ponieważ niektóre opcje mogą spowodować awarię workera, np. --prof, --title. Zobacz https://github.com/nodejs/node/issues/41103.

poolOptions.vmThreads

Opcje dla puli vmThreads.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      vmThreads: {
        // Opcje wątków VM
      },
    },
  },
});

poolOptions.vmThreads.maxThreads*

Typ: number | string
Domyślnie: dostępne procesory

Maksymalna liczba lub procent wątków. Możesz również użyć zmiennej środowiskowej VITEST_MAX_THREADS.

poolOptions.vmThreads.minThreads*

Typ: number | string
Domyślnie: dostępne procesory

Minimalna liczba lub procent wątków. Możesz również użyć zmiennej środowiskowej VITEST_MIN_THREADS.

poolOptions.vmThreads.memoryLimit*

Typ: string | number
Wartość domyślna: 1 / liczba rdzeni CPU

Określa limit pamięci dla workerów przed ich recyklingiem. Ta wartość silnie zależy od twojego środowiska, więc lepiej określić ją ręcznie zamiast polegać na wartości domyślnej.

TIP

Implementacja opiera się na workerIdleMemoryLimit Jesta.

Limit można określić na wiele różnych sposobów, a niezależnie od wyniku, Math.floor jest używany do przekształcenia go w wartość całkowitą:

<= 1 - Zakłada się, że wartość jest procentem pamięci systemowej. Więc 0,5 ustawia limit pamięci workera na połowę całkowitej pamięci systemowej.
\> 1 - Zakłada się, że jest to stała wartość bajtowa. Z powodu poprzedniej reguły, jeśli chcesz uzyskać wartość 1 bajta, możesz użyć 1,1.
Z jednostkami
- 50% - Tak jak wyżej, procent całkowitej pamięci systemowej.
- 100KB, 65MB itp. - Z jednostkami oznaczającymi stałą wartość limitu pamięci.
  - K / KB - Kilobajty (x1000)
  - KiB - Kibibajty (1024 bajty)
  - M / MB - Megabajty
  - MiB - Mebibajty
  - G / GB - Gigabajty
  - GiB - Gibibajty

WARNING

Limit pamięci oparty na procentach nie działa na workerach Linux CircleCI z powodu nieprawidłowo zgłaszanej pamięci systemowej.

poolOptions.vmThreads.useAtomics*

Typ: boolean
Wartość domyślna: false

Używa Atomics do synchronizacji wątków.

Może to poprawić wydajność w niektórych przypadkach, ale może spowodować błąd segmentacji w starszych wersjach Node.

poolOptions.vmThreads.execArgv*

Typ: string[]
Wartość domyślna: []

Przekazuje dodatkowe argumenty do procesu node w kontekście VM. Zobacz Command-line API | Node.js aby uzyskać więcej informacji.

WARNING

Należy zachować ostrożność podczas używania, ponieważ niektóre opcje mogą spowodować awarię workera, np. --prof, --title. Zobacz https://github.com/nodejs/node/issues/41103.

poolOptions.vmForks

Opcje dla puli vmForks.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      vmForks: {
        // Opcje forków VM
      },
    },
  },
});

poolOptions.vmForks.maxForks*

Typ: number | string
Domyślnie: dostępne procesory

Maksymalna liczba lub procent wątków. Możesz również użyć zmiennej środowiskowej VITEST_MAX_FORKS.

poolOptions.vmForks.minForks*

Typ: number | string
Domyślnie: dostępne procesory

Minimalna liczba lub procent wątków. Możesz również użyć zmiennej środowiskowej VITEST_MIN_FORKS.

poolOptions.vmForks.memoryLimit*

Typ: string | number
Wartość domyślna: 1 / liczba rdzeni CPU

Określa limit pamięci dla workerów przed ich recyklingiem. Ta wartość silnie zależy od twojego środowiska, więc lepiej określić ją ręcznie zamiast polegać na wartości domyślnej. Sposób obliczania wartości opisano w poolOptions.vmThreads.memoryLimit

poolOptions.vmForks.execArgv*

Typ: string[]
Wartość domyślna: []

Przekazuje dodatkowe argumenty do procesu node w kontekście VM. Zobacz Command-line API | Node.js aby uzyskać więcej informacji.

WARNING

Należy zachować ostrożność podczas używania, ponieważ niektóre opcje mogą spowodować awarię workera, np. --prof, --title. Zobacz https://github.com/nodejs/node/issues/41103.

fileParallelism*

Typ: boolean (wartość logiczna)
Domyślnie: true
CLI: --no-file-parallelism, --fileParallelism=false

Określa, czy pliki testowe powinny być uruchamiane równolegle.

TIP

Ta opcja nie ma wpływu na testy uruchamiane w obrębie tego samego pliku testowego. Aby uruchamiać testy równolegle w jednym pliku, użyj opcji concurrent w describe lub poprzez konfigurację.

maxWorkers*

Type: number | string

Maksymalna liczba workerów do uruchamiania testów. poolOptions.{threads,vmThreads}.maxThreads/poolOptions.forks.maxForks ma wyższy priorytet.

minWorkers*

Type: number | string

Minimalna liczba lub procent workerów do uruchamiania testów. poolOptions.{threads,vmThreads}.minThreads/poolOptions.forks.minForks ma wyższy priorytet.

testTimeout

Type: number
Domyślnie: 5_000 w Node.js, 15_000 jeśli browser.enabled jest true
CLI: --test-timeout=5000, --testTimeout=5000

Domyślny limit czasu testu w milisekundach.

hookTimeout

Type: number
Domyślnie: 10_000 w Node.js, 30_000 jeśli browser.enabled jest true
CLI: --hook-timeout=10000, --hookTimeout=10000

Domyślny limit czasu haka w milisekundach.

teardownTimeout*

Typ: number (liczba)
Domyślnie: 10000
CLI: --teardown-timeout=5000, --teardownTimeout=5000

Domyślny limit czasu (timeout) na zakończenie działania (teardown) podczas zamykania Vitest, w milisekundach.

silent*

Typ: boolean (wartość logiczna)
Domyślnie: false
CLI: --silent, --silent=false

Wycisza (pomija) wyświetlanie danych wyjściowych konsoli z testów.

setupFiles

Typ: string | string[] (ciąg znaków lub tablica ciągów znaków)

Ścieżka do plików konfiguracyjnych (setup). Pliki te zostaną uruchomione przed każdym plikiem testowym.

INFO

Edycja pliku konfiguracyjnego automatycznie wywoła ponowne uruchomienie wszystkich testów.

Wewnątrz plików setup możesz użyć process.env.VITEST_POOL_ID (ciąg znaków reprezentujący liczbę całkowitą), aby rozróżnić procesy robocze (workers).

TIP

Pamiętaj, że jeśli uruchamiasz Vitest z opcją --isolate=false, plik setup zostanie uruchomiony wielokrotnie w tym samym globalnym zakresie. Oznacza to, że przed każdym testem uzyskujesz dostęp do tego samego obiektu globalnego, więc upewnij się, że nie wykonujesz tych samych operacji więcej razy niż to konieczne.

Przykład użycia zmiennej globalnej:

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

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

// Hooki są resetowane przed każdym zestawem testów (suite)
afterEach(() => {
  cleanup();
});

globalThis.resetBeforeEachTest = true;

provide 2.1.0+

Typ: Partial<ProvidedContext>

Definiuj wartości, do których można uzyskać dostęp w testach za 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

Właściwości muszą być ciągami znaków, a wartości muszą być serializowalne, ponieważ ten obiekt będzie przenoszony między różnymi procesami.

TIP

Jeśli używasz TypeScript, będziesz potrzebować rozszerzyć typ ProvidedContext w celu bezpiecznego dostępu do typów:

// 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[] (ciąg znaków lub tablica ciągów znaków)

Ścieżka do globalnych plików konfiguracyjnych (setup), relatywna do katalogu głównego projektu.

Globalny plik setup może eksportować nazwane funkcje setup i teardown lub funkcję default, która zwraca funkcję teardown (przykład).

INFO

Można użyć wielu globalnych plików setup. Funkcje setup i teardown są wykonywane sekwencyjnie, a funkcje teardown w odwrotnej kolejności.

WARNING

Globalny setup uruchamia się tylko wtedy, gdy jest co najmniej jeden uruchomiony test. Oznacza to, że globalny setup może zacząć działać w trybie obserwacji po zmianie pliku testowego (plik testowy poczeka na globalny setup zanim zacznie działać).

Pamiętaj, że globalny setup działa w innym globalnym zasięgu, więc Twoje testy nie mają dostępu do zdefiniowanych tutaj zmiennych. Możesz jednak przekazać serializowalne dane do testów za 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[] (tablica ciągów znaków)
Domyślnie: ['**/package.json/**', '**/vitest.config.*/**', '**/vite.config.*/**']

Wzorzec glob dla ścieżek plików, których zmiana spowoduje ponowne uruchomienie całego zestawu testów (suite). W połączeniu z argumentem --changed uruchomi cały zestaw testów, jeśli zmiana wyzwalająca (trigger) zostanie znaleziona w git diff.

Przydatne, jeśli testujesz wywoływanie poleceń CLI, ponieważ Vite nie może skonstruować grafu modułów:

test('execute a script', async () => {
  // Vitest nie może ponownie uruchomić tego testu, jeśli zmieni się zawartość `dist/index.js`
  await execa('node', ['dist/index.js']);
});

TIP

Upewnij się, że twoje pliki nie są wykluczone przez server.watch.ignored.

coverage*

Możesz użyć v8, istanbul lub niestandardowego rozwiązania do obsługi coverage do zbierania informacji o pokryciu kodu.

Możesz przekazywać opcje coverage do CLI, używając notacji kropkowej:

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

WARNING

Jeśli używasz opcji coverage w notacji kropkowej, nie zapomnij określić --coverage.enabled. Nie używaj pojedynczej opcji --coverage w takim przypadku.

coverage.provider

Typ: 'v8' | 'istanbul' | 'custom' (v8, istanbul lub custom)
Domyślnie: 'v8'
CLI: --coverage.provider=<provider>

Użyj provider, aby wybrać narzędzie do zbierania informacji o pokryciu kodu.

coverage.enabled

Typ: boolean (wartość logiczna)
Domyślnie: false
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.enabled, --coverage.enabled=false

Włącza zbieranie informacji o pokryciu kodu. Można to nadpisać opcją CLI --coverage.

coverage.include

Typ: string[] (tablica ciągów znaków)
Domyślnie: ['**']
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.include=<path>, --coverage.include=<path1> --coverage.include=<path2>

Lista plików uwzględnionych w pokryciu kodu, określona jako wzorce glob.

coverage.extension

Typ: string | string[] (ciąg znaków lub tablica ciągów znaków)
Domyślnie: ['.js', '.cjs', '.mjs', '.ts', '.mts', '.tsx', '.jsx', '.vue', '.svelte', '.marko', '.astro']
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.extension=<extension>, --coverage.extension=<extension1> --coverage.extension=<extension2>

coverage.exclude

Typ: string[] (tablica ciągów znaków)
Domyślnie:

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

Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.exclude=<path>, --coverage.exclude=<path1> --coverage.exclude=<path2>

Lista plików wykluczonych z pokrycia kodu, określona jako wzorce glob.

Ta opcja nadpisuje domyślne ustawienia. Aby dodać nowe wzorce do ignorowania, rozszerz domyślne ustawienia.

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

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

UWAGA

Vitest automatycznie dodaje wzorce include dla plików testowych do domyślnej wartości coverage.exclude.

coverage.all

Typ: boolean
Domyślnie: true
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.all, --coverage.all=false

Określa, czy uwzględniać wszystkie pliki, w tym te nieprzetestowane, w raporcie pokrycia kodu.

coverage.clean

Typ: boolean (wartość logiczna)
Domyślnie: true
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.clean, --coverage.clean=false

Czyści wyniki pokrycia kodu przed uruchomieniem testów.

coverage.cleanOnRerun

Typ: boolean (wartość logiczna)
Domyślnie: true
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.cleanOnRerun, --coverage.cleanOnRerun=false

Wyczyść raport pokrycia podczas ponownego uruchomienia w trybie oglądania. Ustaw na false, aby zachować wyniki pokrycia z poprzedniego uruchomienia w trybie oglądania.

coverage.reportsDirectory

Typ: string (ciąg znaków)
Domyślnie: './coverage'
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.reportsDirectory=<path>

WARNING

Vitest usunie ten katalog przed uruchomieniem testów, jeśli opcja coverage.clean jest włączona (wartość domyślna).

Katalog, w którym ma zostać zapisany raport pokrycia kodu.

Aby wyświetlić podgląd raportu pokrycia kodu w wynikach reportera HTML, ta opcja musi być ustawiona jako podkatalog katalogu raportu HTML (na przykład ./html/coverage).

coverage.reporter

Typ: string | string[] | [string, {}][] (ciąg znaków, tablica ciągów znaków lub tablica tablic [ciąg znaków, obiekt])
Domyślnie: ['text', 'html', 'clover', 'json']
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.reporter=<reporter>, --coverage.reporter=<reporter1> --coverage.reporter=<reporter2>

Reportery coverage do użycia. Zobacz dokumentację istanbul dla szczegółowej listy wszystkich reporterów. Zobacz @types/istanbul-reporter aby uzyskać szczegółowe informacje na temat opcji specyficznych dla reportera.

Reporter może mieć trzy różne formaty:

Pojedynczy reporter: { reporter: 'html' }
Wiele reporterów bez opcji: { reporter: ['html', 'json'] }

Pojedynczy lub wielu reporterów z opcjami reportera:

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

Możesz również przekazać niestandardowe raporty pokrycia. Więcej informacji znajdziesz w Przewodniku - Niestandardowy raport pokrycia.

{
  reporter: [
    // Określ reportera używając nazwy pakietu NPM
    '@vitest/custom-coverage-reporter',
    ['@vitest/custom-coverage-reporter', { someOption: true }],

    // Określ reportera używając lokalnej ścieżki
    '/absolute/path/to/custom-reporter.cjs',
    ['/absolute/path/to/custom-reporter.cjs', { someOption: true }],
  ];
}

Możesz sprawdzić swój raport pokrycia w Vitest UI: sprawdź Pokrycie Vitest UI, aby uzyskać więcej szczegółów.

coverage.reportOnFailure

Typ: boolean
Domyślnie: false
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.reportOnFailure, --coverage.reportOnFailure=false

Generuje raport coverage nawet wtedy, gdy testy się nie powiodą.

coverage.allowExternal

Typ: boolean (wartość logiczna)
Domyślnie: false
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.allowExternal, --coverage.allowExternal=false

Zbiera informacje o pokryciu kodu dla plików spoza katalogu root projektu.

coverage.excludeAfterRemap 2.1.0+

Typ: boolean
Domyślnie: false
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.excludeAfterRemap, --coverage.excludeAfterRemap=false

Ponownie zastosuj wykluczenia po zmapowaniu pokrycia na oryginalne źródła. Jest to przydatne, gdy pliki źródłowe są transpilowane i mogą zawierać mapy źródłowe plików innych niż źródłowe.

Użyj tej opcji, gdy zobaczysz pliki, które pojawiają się w raporcie, nawet jeśli pasują do wzorców coverage.exclude.

coverage.skipFull

Typ: boolean (wartość logiczna)
Domyślnie: false
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.skipFull, --coverage.skipFull=false

Nie wyświetla plików ze 100% pokryciem instrukcji, gałęzi i funkcji.

coverage.thresholds

Opcje progów pokrycia kodu (coverage thresholds).

coverage.thresholds.lines

Typ: number (liczba)
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.thresholds.lines=<number>

Globalny próg dla pokrycia linii. Zobacz dokumentację istanbul aby uzyskać więcej informacji.

coverage.thresholds.functions

Typ: number (liczba)
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.thresholds.functions=<number>

Globalny próg dla pokrycia funkcji. Zobacz dokumentację istanbul aby uzyskać więcej informacji.

coverage.thresholds.branches

Typ: number (liczba)
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.thresholds.branches=<number>

Globalny próg dla pokrycia gałęzi. Zobacz dokumentację istanbul aby uzyskać więcej informacji.

coverage.thresholds.statements

Typ: number (liczba)
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.thresholds.statements=<number>

Globalny próg dla pokrycia instrukcji. Zobacz dokumentację istanbul aby uzyskać więcej informacji.

coverage.thresholds.perFile

Typ: boolean (wartość logiczna)
Domyślnie: false
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.thresholds.perFile, --coverage.thresholds.perFile=false

Sprawdza progi pokrycia kodu dla każdego pliku oddzielnie.

coverage.thresholds.autoUpdate

Typ: boolean (wartość logiczna)
Domyślnie: false
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.thresholds.autoUpdate=<boolean>

Aktualizuje wszystkie wartości progowe lines, functions, branches i statements w pliku konfiguracyjnym, gdy bieżące pokrycie kodu przekracza skonfigurowane progi. Ta opcja pomaga w utrzymaniu progów, gdy pokrycie kodu jest poprawiane.

coverage.thresholds.100

Typ: boolean (wartość logiczna)
Domyślnie: false
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.thresholds.100, --coverage.thresholds.100=false

Ustawia globalne progi na wartość 100. Skrót dla --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 } (obiekt z opcjonalnymi właściwościami: statements, functions, branches, lines - wszystkie typu number)
Domyślnie: undefined
Dostępne dla dostawców: 'v8' | 'istanbul'

Ustawia progi pokrycia kodu dla plików pasujących do wzorców glob.

UWAGA

Vitest wlicza wszystkie pliki, w tym te objęte wzorcami glob, do globalnych progów pokrycia. Różni się to od zachowania Jest.

{
  coverage: {
    thresholds: {
      // Progi dla wszystkich plików
      functions: 95,
      branches: 70,

      // Progi dla plików pasujących do wzorca glob
      'src/utils/**.ts': {
        statements: 95,
        functions: 90,
        branches: 85,
        lines: 80,
      },

      // Pliki pasujące do tego wzorca będą miały ustawione tylko progi dla linii.
      // Globalne progi nie są dziedziczone.
      '**/math.ts': {
        lines: 100,
      }
    }
  }
}

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

Typ: boolean
Domyślnie: false
Dostępne dla providerów: 'v8' | 'istanbul'

Ustawia progi na 100 dla plików pasujących do wzorca glob.

{
  coverage: {
    thresholds: {
      // Progi dla wszystkich plików
      functions: 95,
      branches: 70,

      // Progi dla plików pasujących do wzorca glob
      'src/utils/**.ts': { 100: true },
      '**/math.ts': { 100: true }
    }
  }
}

coverage.ignoreEmptyLines

Typ: boolean (wartość logiczna)
Domyślnie: true (false w wersji v1)
Dostępne dla dostawców: 'v8'
CLI: --coverage.ignoreEmptyLines=<boolean>

Ignoruje puste linie, komentarze i inny kod niebędący kodem wykonywalnym, np. typy Typescript.

Ta opcja działa tylko wtedy, gdy używany kompilator usuwa komentarze i inny kod niebędący kodem wykonywalnym z transpilowanego kodu. Domyślnie Vite używa ESBuild, który usuwa komentarze i typy Typescript z plików .ts, .tsx i .jsx.

Jeśli chcesz zastosować ESBuild również do innych plików, zdefiniuj je w opcjach esbuild:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  esbuild: {
    // Transpiluj wszystkie pliki za pomocą ESBuild, aby usunąć komentarze z pokrycia kodu.
    // Wymagane, aby `test.coverage.ignoreEmptyLines` działało:
    include: ['**/*.js', '**/*.jsx', '**/*.mjs', '**/*.ts', '**/*.tsx'],
  },
  test: {
    coverage: {
      provider: 'v8',
      ignoreEmptyLines: true,
    },
  },
});

coverage.ignoreClassMethods

Typ: string[] (tablica ciągów znaków)
Domyślnie: []
Dostępne dla dostawców: 'istanbul'
CLI: --coverage.ignoreClassMethods=<method>

Ustaw na tablicę nazw metod klas do ignorowania podczas obliczania pokrycia kodu. Zobacz dokumentację istanbul aby uzyskać więcej informacji.

coverage.watermarks

Typ:

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

Domyślnie:

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

Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.watermarks.statements=50,80, --coverage.watermarks.branches=50,80

Znaczniki wodne (watermarks) dla instrukcji, linii, gałęzi i funkcji. Zobacz dokumentację istanbul aby uzyskać więcej informacji.

coverage.processingConcurrency

Typ: boolean (wartość logiczna)
Domyślnie: Math.min(20, os.availableParallelism?.() ?? os.cpus().length)
Dostępne dla dostawców: 'v8' | 'istanbul'
CLI: --coverage.processingConcurrency=<number>

Maksymalna liczba procesów używanych podczas przetwarzania wyników pokrycia kodu.

coverage.customProviderModule

Typ: string (ciąg znaków)
Dostępne dla dostawców: 'custom'
CLI: --coverage.customProviderModule=<path or module name>

Określa nazwę modułu lub ścieżkę do niestandardowego modułu dostawcy pokrycia kodu. Zobacz Przewodnik - Niestandardowy dostawca pokrycia kodu aby uzyskać więcej informacji.

testNamePattern*

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

Uruchamia testy, których pełne nazwy pasują do wzorca. Dodanie OnlyRunThis do nazwy testu spowoduje pominięcie testów, które nie zawierają słowa OnlyRunThis w nazwie.

import { expect, test } from 'vitest';

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

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

open*

Typ: boolean
Domyślnie: !process.env.CI
CLI: --open, --open=false

Otwiera interfejs użytkownika Vitest (w trakcie prac rozwojowych).

api

Typ: boolean | number
Domyślnie: false
CLI: --api, --api.port, --api.host, --api.strictPort

Uruchamia serwer API nasłuchujący na określonym porcie. Gdy ustawione na true, domyślny port to 51204.

browser

Typ: { enabled?, name?, provider?, headless?, api? }
Domyślnie: { enabled: false, headless: process.env.CI, api: 63315 }
CLI: --browser, --browser=<name>, --browser.name=chrome --browser.headless

Uruchamia testy Vitest w przeglądarkach. Domyślnie używany jest WebdriverIO do uruchamiania testów, ale można to skonfigurować za pomocą opcji browser.provider.

UWAGA

Przeczytaj więcej o testowaniu w prawdziwej przeglądarce na stronie przewodnika.

WARNING

To jest eksperymentalna funkcja. Zmiany powodujące niezgodność mogą nie być zgodne z SemVer, dlatego podczas korzystania z niej zaleca się przypięcie wersji Vitest.

browser.enabled

Typ: boolean
Domyślnie: false
CLI: --browser, --browser.enabled=false

Domyślnie uruchamia wszystkie testy w przeglądarce. Można to zmienić za pomocą opcji poolMatchGlobs.

browser.name

Typ: string
CLI: --browser=safari

Uruchamia wszystkie testy w określonej przeglądarce. Dostępne opcje w zależności od dostawcy:

webdriverio: firefox, chrome, edge, safari
playwright: firefox, webkit, chromium
custom: dowolny ciąg znaków, który zostanie przekazany do niestandardowego dostawcy

browser.headless

Typ: boolean
Domyślnie: process.env.CI
CLI: --browser.headless, --browser.headless=false

Uruchamia przeglądarkę w trybie headless (bez interfejsu graficznego). Jeśli uruchamiasz Vitest w CI, ta opcja jest domyślnie włączona.

browser.isolate

Typ: boolean
Domyślnie: true
CLI: --browser.isolate, --browser.isolate=false

Uruchamia każdy test w oddzielnym iframe.

browser.testerHtmlPath

Typ: string
Domyślnie: @vitest/browser/tester.html
Wersja: Od Vitest 2.1.4

Ścieżka do pliku wejściowego HTML. Może być względna względem katalogu głównego projektu. Ten plik zostanie przetworzony za pomocą haka transformIndexHtml.

browser.api

Typ: number | { port?, strictPort?, host? }
Domyślnie: 63315
CLI: --browser.api=63315, --browser.api.port=1234, --browser.api.host=example.com

Konfiguruje opcje serwera Vite, który dostarcza kod do przeglądarki. Nie wpływa na opcję test.api. Domyślnie Vitest przypisuje port 63315, aby uniknąć konfliktów z serwerem deweloperskim, co pozwala na równoległe uruchamianie obu.

browser.provider

Typ: 'webdriverio' | 'playwright' | 'preview' | string
Domyślnie: 'preview'
CLI: --browser.provider=playwright

Ścieżka do dostawcy usług, który będzie używany podczas uruchamiania testów w przeglądarce. Vitest udostępnia trzech dostawców: preview (domyślny), webdriverio i playwright. Dostawcy niestandardowi powinni być eksportowani za pomocą eksportu default i mieć następującą postać:

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

Jest to zaawansowany interfejs API dla autorów bibliotek. Jeśli potrzebujesz tylko uruchomić testy w przeglądarce, użyj opcji browser.

browser.providerOptions

Typ: BrowserProviderOptions

Opcje, które zostaną przekazane do dostawcy podczas wywoływania provider.initialize.

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

TIP

Aby uzyskać lepsze bezpieczeństwo typów podczas korzystania z wbudowanych dostawców, możesz dodać jeden z tych typów (dla używanego dostawcy) do pola compilerOptions.types w pliku tsconfig.json:

json

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

browser.ui

Typ: boolean
Domyślnie: !isCI
CLI: --browser.ui=false

Czy interfejs użytkownika Vitest powinien zostać wstrzyknięty do strony. Domyślnie, wstrzykuje iframe UI podczas programowania.

browser.viewport

Typ: { width, height }
Domyślnie: 414x896

Domyślny widok iframe.

browser.locators

Opcje dla wbudowanych lokalizatorów przeglądarki.

browser.locators.testIdAttribute

Typ: string
Domyślnie: data-testid

Atrybut używany do znajdowania elementów za pomocą lokalizatora getByTestId.

browser.screenshotDirectory

Typ: string
Domyślnie: __snapshots__ w katalogu z plikami testów

Ścieżka do katalogu ze zrzutami ekranu, relatywnie do root.

browser.screenshotFailures

Typ: boolean
Domyślnie: !browser.ui

Vitest powinien wykonywać zrzuty ekranu, jeśli test zakończy się niepowodzeniem.

browser.orchestratorScripts

Typ: BrowserScript[]
Domyślnie: []

Niestandardowe skrypty, które powinny zostać wstrzyknięte do HTML orchestratora przed zainicjowaniem iframe'ów testowych. Ten dokument HTML tylko konfiguruje iframe'y i w rzeczywistości nie importuje Twojego kodu.

Skrypty src i content będą przetwarzane przez wtyczki Vite. Skrypt powinien być dostarczony w następującej strukturze:

export interface BrowserScript {
  /**
   * Jeśli podano "content" i typ to "module", to będzie to jego identyfikator.
   *
   * Jeśli używasz TypeScript, możesz tutaj dodać na przykład rozszerzenie `.ts`.
   * @default `injected-${index}.js`
   */
  id?: string;
  /**
   * Zawartość JavaScript do wstrzyknięcia. Ten ciąg znaków jest przetwarzany przez wtyczki Vite, jeśli typ to "module".
   *
   * Możesz użyć `id`, aby dać Vite wskazówkę dotyczącą rozszerzenia pliku.
   */
  content?: string;
  /**
   * Ścieżka do skryptu. Ta wartość jest rozwiązywana przez Vite, więc może to być moduł node lub ścieżka pliku.
   */
  src?: string;
  /**
   * Określa, czy skrypt powinien być ładowany asynchronicznie.
   */
  async?: boolean;
  /**
   * Typ skryptu.
   * @default 'module'
   */
  type?: string;
}

browser.testerScripts

Typ: BrowserScript[]
Domyślnie: []

Niestandardowe skrypty, które powinny zostać wstrzyknięte do testera HTML przed zainicjowaniem środowiska testowego. Jest to przydatne do wstrzykiwania polyfilli wymaganych przez implementację przeglądarkową Vitest. Zaleca się używanie setupFiles w większości przypadków.

Skrypty src i content będą przetwarzane przez wtyczki Vite.

browser.commands

Typ: Record<string, BrowserCommand>
Domyślnie: { readFile, writeFile, ... }

Niestandardowe polecenia, które można zaimportować podczas testów przeglądarki z modułu @vitest/browser/commands.

clearMocks

Typ: boolean
Domyślnie: false

Powoduje wywołanie .mockClear() na wszystkich mockach przed każdym testem. Powoduje to wyczyszczenie historii mocków, ale nie zresetuje ich implementacji do domyślnej.

mockReset

Typ: boolean
Domyślnie: false

Powoduje wywołanie .mockReset() na wszystkich mockach przed każdym testem. Powoduje to wyczyszczenie historii mocków i zresetuje ich implementację do pustej funkcji (zwróci undefined).

restoreMocks

Typ: boolean
Domyślnie: false

Powoduje wywołanie .mockRestore() na wszystkich mockach przed każdym testem. Powoduje to wyczyszczenie historii mocków i zresetuje ich implementację do oryginalnej.

unstubEnvs

Typ: boolean
Domyślnie: false

Wywoła vi.unstubAllEnvs przed każdym testem.

unstubGlobals

Typ: boolean
Domyślnie: false

Wywoła vi.unstubAllGlobals przed każdym testem.

testTransformMode

Typ: { web?, ssr? }

Określa metodę transformacji dla wszystkich modułów importowanych wewnątrz testu, które pasują do wzorca glob. Domyślne zachowanie zależy od środowiska testowego. Na przykład testy ze środowiskiem JSDOM będą przetwarzać wszystkie pliki z flagą ssr: false, a testy ze środowiskiem Node będą przetwarzać wszystkie moduły z ssr: true.

testTransformMode.ssr

Typ: string[]
Domyślnie: []

Używa potoku transformacji SSR dla wszystkich modułów wewnątrz określonych testów.
Wtyczki Vite otrzymają flagę ssr: true podczas przetwarzania tych plików.

testTransformMode.web

Typ: string[]
Domyślnie: []

Najpierw stosuje standardowy potok transformacji (dla przeglądarki), a następnie przepisuje kod w stylu SSR, aby umożliwić jego uruchomienie w Node. Wtyczki Vite otrzymają flagę ssr: false podczas przetwarzania tych plików.

snapshotFormat*

Typ: PrettyFormatOptions

Opcje formatowania dla testowania migawek. Te opcje są przekazywane do pretty-format.

TIP

Pamiętaj, że pole plugins w tym obiekcie zostanie zignorowane.

Jeśli chcesz rozszerzyć serializator migawek za pomocą wtyczek pretty-format, użyj API expect.addSnapshotSerializer lub opcji snapshotSerializers.

snapshotSerializers*

Typ: string[]
Domyślnie: []

Lista ścieżek do modułów serializatorów migawek, przydatna, jeśli chcesz dodać niestandardowe serializatory migawek. Zobacz Custom Serializer aby uzyskać więcej informacji.

resolveSnapshotPath*

Typ: (testPath: string, snapExtension: string) => string
Domyślnie: przechowuje pliki migawek w katalogu __snapshots__

Zastępuje domyślną ścieżkę migawek. Na przykład, aby przechowywać migawki obok plików testowych:

import { defineConfig } from 'vitest/config';

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

allowOnly

Typ: boolean
Domyślnie: !process.env.CI
CLI: --allowOnly, --allowOnly=false

Umożliwia uruchamianie testów i zestawów testów oznaczonych jako "only".

dangerouslyIgnoreUnhandledErrors*

Typ: boolean
Domyślnie: false
CLI: --dangerouslyIgnoreUnhandledErrors --dangerouslyIgnoreUnhandledErrors=false

Ignoruje wszelkie nieobsłużone błędy, które mogą wystąpić. Używaj ostrożnie.

passWithNoTests*

Typ: boolean
Domyślnie: false
CLI: --passWithNoTests, --passWithNoTests=false

Vitest nie zakończy się niepowodzeniem, jeśli nie zostaną znalezione żadne testy.

logHeapUsage

Typ: boolean
Domyślnie: false
CLI: --logHeapUsage, --logHeapUsage=false

Wyświetla użycie pamięci sterty po każdym teście. Przydatne do debugowania wycieków pamięci.

css

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

Konfiguruje, czy CSS powinien być przetwarzany. Po wykluczeniu pliki CSS zostaną zastąpione pustymi ciągami znaków, aby pominąć dalsze przetwarzanie. Moduły CSS zwrócą proxy, aby uniknąć wpływu na działanie aplikacji.

css.include

Typ: RegExp | RegExp[]
Domyślnie: []

Wzorzec RegExp dla plików, które powinny zwracać rzeczywisty CSS i będą przetwarzane przez potok Vite.

TIP

Aby przetworzyć wszystkie pliki CSS, użyj /.+/.

css.exclude

Typ: RegExp | RegExp[]
Domyślnie: []

Wzorzec RegExp dla plików, które zwrócą pusty plik CSS.

css.modules

Typ: { classNameStrategy? }
Domyślnie: {}

css.modules.classNameStrategy

Typ: 'stable' | 'scoped' | 'non-scoped'
Domyślnie: 'stable'

Jeśli włączysz przetwarzanie plików CSS, możesz skonfigurować, czy nazwy klas w modułach CSS powinny być zakresowe (scoped). Możesz wybrać jedną z opcji:

stable: nazwy klas będą generowane jako _${name}_${hashedFilename}, co oznacza, że wygenerowana klasa pozostanie taka sama, jeśli zawartość CSS zostanie zmieniona, ale zmieni się, jeśli nazwa pliku zostanie zmodyfikowana lub plik zostanie przeniesiony do innego folderu. To ustawienie jest przydatne, jeśli używasz funkcji migawek.
scoped: nazwy klas będą generowane jak zwykle, z uwzględnieniem metody css.modules.generateScopedName, jeśli ją masz i przetwarzanie CSS jest włączone. Domyślnie nazwa pliku będzie generowana jako _${name}_${hash}, gdzie hash zawiera nazwę pliku i zawartość pliku.
non-scoped: nazwy klas nie będą haszowane.

WARNING

Domyślnie Vitest eksportuje proxy, pomijając przetwarzanie modułów CSS. Jeśli korzystasz z właściwości CSS w swoich klasach, musisz włączyć przetwarzanie CSS za pomocą opcji include.

maxConcurrency

Typ: number
Domyślnie: 5
CLI: --max-concurrency=10, --maxConcurrency=10

Określa maksymalną liczbę testów oznaczonych jako test.concurrent, które mogą być uruchamiane równocześnie.

Testy przekraczające ten limit zostaną umieszczone w kolejce i uruchomione, gdy tylko zwolni się miejsce.

cache*

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

Wyłącza mechanizm pamięci podręcznej (cache). Domyślnie Vitest przechowuje w pamięci podręcznej wyniki testów, aby priorytetowo uruchamiać testy trwające najdłużej i te, które zakończyły się niepowodzeniem.

Katalog pamięci podręcznej jest kontrolowany przez opcję cacheDir Vite:

import { defineConfig } from 'vitest/config';

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

Możesz ograniczyć katalog tylko dla Vitest, używając 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? }

Opcje konfigurujące kolejność wykonywania testów.

Możesz przekazywać opcje sekwencji za pomocą CLI, używając notacji kropkowej:

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

sequence.sequencer*

Typ: TestSequencerConstructor
Domyślnie: BaseSequencer

Niestandardowa klasa, która definiuje logikę podziału i sortowania testów. Możesz rozszerzyć klasę BaseSequencer z pakietu vitest/node, jeśli potrzebujesz zmodyfikować tylko jedną z metod sort lub shard, ale obie metody muszą być zdefiniowane.

Dzielenie na fragmenty (sharding) odbywa się przed sortowaniem i tylko wtedy, gdy używana jest opcja --shard.

sequence.shuffle

Typ: boolean | { files?, tests? }
Domyślnie: false
CLI: --sequence.shuffle, --sequence.shuffle=false

Włącza losowe uruchamianie plików i testów. Możesz to zrobić za pomocą tej opcji lub argumentu CLI --sequence.shuffle.

Vitest domyślnie wykorzystuje pamięć podręczną do optymalizacji kolejności testów, uruchamiając najpierw testy trwające najdłużej, co przyspiesza cały proces. Włączenie losowej kolejności wyłącza tę optymalizację, ale może pomóc w wykryciu testów, które nieoczekiwanie zależą od stanu po poprzednich uruchomieniach.

sequence.shuffle.files

Typ: boolean
Domyślnie: false
CLI: --sequence.shuffle.files, --sequence.shuffle.files=false

Włącza losowanie kolejności plików. Pamiętaj, że optymalizacja polegająca na wcześniejszym uruchamianiu długotrwałych testów nie będzie działać, jeśli ta opcja jest włączona.

sequence.shuffle.tests

Typ: boolean
Domyślnie: false
CLI: --sequence.shuffle.tests, --sequence.shuffle.tests=false

Włącza losowanie kolejności testów w obrębie plików.

sequence.concurrent

Typ: boolean
Domyślnie: false
CLI: --sequence.concurrent, --sequence.concurrent=false

Włącza równoległe uruchamianie testów. Możesz to zrobić za pomocą tej opcji lub argumentu CLI --sequence.concurrent.

sequence.seed*

Typ: number
Domyślnie: Date.now()
CLI: --sequence.seed=1000

Ustawia ziarno generatora liczb losowych, używane podczas uruchamiania testów w losowej kolejności.

sequence.hooks

Typ: 'stack' | 'list' | 'parallel'
Domyślnie: 'parallel'
CLI: --sequence.hooks=<wartość>

Określa kolejność wykonywania hooków (funkcji uruchamianych przed i po testach).

stack: Hooki "after" są uruchamiane w odwrotnej kolejności, a hooki "before" w kolejności, w jakiej zostały zdefiniowane.
list: Wszystkie hooki są uruchamiane w kolejności, w jakiej zostały zdefiniowane.
parallel: Hooki w jednej grupie są uruchamiane równolegle (hooki w nadrzędnych zestawach testowych nadal będą uruchamiane przed hookami bieżącego zestawu testów).

TIP

Ta opcja nie wpływa na onTestFinished. Ta funkcja jest zawsze wywoływana w odwrotnej kolejności.

sequence.setupFiles

Typ: 'list' | 'parallel'
Domyślnie: 'parallel'
CLI: --sequence.setupFiles=<wartość>

Zmienia kolejność wykonywania plików konfiguracyjnych (setup files).

list: Pliki konfiguracyjne są uruchamiane w kolejności, w jakiej zostały zdefiniowane.
parallel: Pliki konfiguracyjne są uruchamiane równolegle.

typecheck

Opcje konfiguracji środowiska testowego dla sprawdzania typów.

typecheck.enabled

Typ: boolean
Domyślnie: false
CLI: --typecheck, --typecheck.enabled

Włącza sprawdzanie typów razem z regularnymi testami.

typecheck.only

Typ: boolean
Domyślnie: false
CLI: --typecheck.only

Uruchamia tylko testy sprawdzania typów, gdy ta opcja jest włączona. Podczas korzystania z CLI, ta opcja automatycznie włączy sprawdzanie typów.

typecheck.checker

Typ: 'tsc' | 'vue-tsc' | string
Domyślnie: tsc

Określa narzędzie, które ma być używane do sprawdzania typów. Vitest uruchomi proces z odpowiednimi parametrami, aby ułatwić parsowanie wyników, w zależności od wybranego narzędzia. Narzędzie powinno generować wyjście w formacie zgodnym z tsc.

Aby użyć danego typecheckera, musisz zainstalować odpowiedni pakiet:

tsc wymaga pakietu typescript
vue-tsc wymaga pakietu vue-tsc

Możesz również podać ścieżkę do niestandardowego pliku binarnego lub nazwę polecenia, które generuje wyjście w formacie tsc --noEmit --pretty false.

typecheck.include

Typ: string[]
Domyślnie: ['**/*.{test,spec}-d.?(c|m)[jt]s?(x)']

Wzorzec glob dla plików, które mają być traktowane jako pliki testowe (definicje typów).

typecheck.exclude

Typ: string[]
Domyślnie: ['**/node_modules/**', '**/dist/**', '**/cypress/**', '**/.{idea,git,cache,output,temp}/**']

Wzorzec glob dla plików, które nie mają być traktowane jako pliki testowe.

typecheck.allowJs

Typ: boolean
Domyślnie: false

Sprawdza pliki JS, które zawierają komentarz @ts-check. Jeśli ta opcja jest włączona w tsconfig, to to ustawienie jej nie nadpisze.

typecheck.ignoreSourceErrors

Typ: boolean
Domyślnie: false

Zapobiega przerwaniu działania, gdy Vitest znajdzie błędy poza plikami testowymi. Spowoduje to ukrycie błędów w kodzie źródłowym, które nie są bezpośrednio związane z testami.

Domyślnie, jeśli Vitest znajdzie błąd w kodzie źródłowym, przerwie wykonywanie zestawu testów.

typecheck.tsconfig

Typ: string
Domyślnie: próbuje znaleźć najbliższy plik tsconfig.json

Ścieżka do niestandardowego pliku tsconfig, relatywna do korzenia projektu.

slowTestThreshold*

Typ: number
Domyślnie: 300
CLI: --slow-test-threshold=<liczba>, --slowTestThreshold=<liczba>

Liczba milisekund, po której test lub pakiet testów jest uważany za wolny i zgłaszany jako taki w wynikach.

chaiConfig

Typ: { includeStack?, showDiff?, truncateThreshold? }
Domyślnie: { includeStack: false, showDiff: true, truncateThreshold: 40 }

Konfiguracja przekazywana do Chai.

chaiConfig.includeStack

Typ: boolean
Domyślnie: false

Określa, czy ślad stosu ma być dołączany do komunikatu o błędzie asercji. Domyślna wartość false pomija ślad stosu.

chaiConfig.showDiff

Typ: boolean
Domyślnie: true

Określa, czy flaga showDiff powinna być dołączana do zgłaszanych błędów AssertionError. Wartość false zawsze wyłączy wyświetlanie różnic, natomiast true włączy je, jeśli asercja tego wymaga.

chaiConfig.truncateThreshold

Typ: number
Domyślnie: 40

Ustawia próg długości dla rzeczywistych i oczekiwanych wartości w błędach asercji. Jeśli ten próg zostanie przekroczony (np. dla dużych struktur danych), wartość zostanie zastąpiona skróconą reprezentacją, np. [ Array(3) ] lub { Object (prop1, prop2) }. Ustaw na 0, aby całkowicie wyłączyć obcinanie.

Ta opcja wpływa na obcinanie wartości w tytułach test.each oraz wewnątrz komunikatów o błędach asercji.

bail

Typ: number
Domyślnie: 0
CLI: --bail=<wartość>

Przerywa wykonywanie testów po osiągnięciu określonej liczby nieudanych testów.

Domyślnie Vitest uruchamia wszystkie przypadki testowe, nawet jeśli niektóre z nich zakończą się niepowodzeniem. Może to być niepożądane w środowisku CI, gdzie oczekiwane są tylko w 100% udane kompilacje i chcesz zatrzymać wykonywanie testów tak szybko, jak to możliwe po wystąpieniu błędów. Opcja bail przyspiesza działanie CI, ponieważ zatrzymuje dalsze testy po wystąpieniu określonej liczby błędów.

retry

Typ: number
Domyślnie: 0
CLI: --retry=<wartość>

Ponawia test określoną liczbę razy, jeśli zakończy się niepowodzeniem.

onConsoleLog*

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

Niestandardowy handler dla console.log w testach. Jeśli funkcja zwróci false, Vitest nie wyświetli logu w konsoli.

Może być przydatne do filtrowania logów pochodzących z bibliotek zewnętrznych.

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

Umożliwia zastosowanie funkcji filtrującej do każdej ramki każdego śladu stosu podczas obsługi błędów. Pierwszy argument, error, jest obiektem o właściwościach identycznych jak standardowy Error, ale nie jest jego rzeczywistą instancją.

Może być przydatne do filtrowania ramek śladu stosu pochodzących z bibliotek zewnętrznych.

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

export default defineConfig({
  test: {
    onStackTrace(error: Error, { file }: ParsedStack): boolean | void {
      // Jeśli napotkaliśmy ReferenceError, pokaż cały stos.
      if (error.name === 'ReferenceError') return;

      // Odrzuć wszystkie ramki z bibliotek zewnętrznych.
      if (file.includes('node_modules')) return false;
    },
  },
});

diff

Typ: string
CLI: --diff=<wartość>

Ścieżka do pliku konfiguracyjnego diff, który będzie używany do generowania interfejsu różnic (diff). Przydatne, jeśli chcesz dostosować sposób wyświetlania różnic.

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
Domyślnie: 0

Maksymalna długość wyniku diff do wyświetlenia. Diffs przekraczające ten próg zostaną obcięte. Obcinanie nie zadziała z domyślną wartością 0.

diff.truncateAnnotation

Typ: string
Domyślnie: '... Diff result is truncated'

Adnotacja, która jest wyświetlana na końcu wyniku diff, jeśli został on obcięty.

diff.truncateAnnotationColor

Typ: DiffOptionsColor = (arg: string) => string
Domyślnie: noColor = (string: string): string => string

Kolor adnotacji obcięcia. Domyślnie jest wyświetlana bez koloru.

fakeTimers

Typ: FakeTimerInstallOpts

Opcje, które Vitest przekaże do @sinon/fake-timers podczas korzystania z vi.useFakeTimers().

fakeTimers.now

Typ: number | Date
Domyślnie: Date.now()

Instaluje fałszywe timery z określonym czasem epoki Unix.

fakeTimers.toFake

Typ: ('setTimeout' | 'clearTimeout' | 'setImmediate' | 'clearImmediate' | 'setInterval' | 'clearInterval' | 'Date' | 'nextTick' | 'hrtime' | 'requestAnimationFrame' | 'cancelAnimationFrame' | 'requestIdleCallback' | 'cancelIdleCallback' | 'performance' | 'queueMicrotask')[]
Domyślnie: ['setTimeout', 'clearTimeout', 'setImmediate', 'clearImmediate', 'setInterval', 'clearInterval', 'Date']

Tablica z nazwami globalnych metod i API, które mają być podrobione (mockowane).

Aby mockować tylko setTimeout() i nextTick(), ustaw tę właściwość na ['setTimeout', 'nextTick'].

Mockowanie nextTick nie jest obsługiwane, gdy Vitest jest uruchamiany wewnątrz node:child_process za pomocą --pool=forks. NodeJS używa process.nextTick wewnętrznie w node:child_process i zawiesza się, gdy jest mockowany. Mockowanie nextTick jest obsługiwane, gdy Vitest jest uruchamiany z --pool=threads.

fakeTimers.loopLimit

Typ: number
Domyślnie: 10_000

Maksymalna liczba timerów, które zostaną uruchomione podczas wywoływania vi.runAllTimers().

fakeTimers.shouldAdvanceTime

Typ: boolean
Domyślnie: false

Nakazuje @sinonjs/fake-timers automatyczne zwiększanie mockowanego czasu na podstawie zmian w czasie systemowym (np. mockowany czas zwiększy się o 20 ms na każde 20 ms zmiany w czasie systemowym).

fakeTimers.advanceTimeDelta

Typ: number
Domyślnie: 20

Istotne tylko w przypadku używania z shouldAdvanceTime: true. Zwiększa mockowany czas o advanceTimeDelta ms na każde advanceTimeDelta ms zmiany w rzeczywistym czasie systemowym.

fakeTimers.shouldClearNativeTimers

Typ: boolean
Domyślnie: true

Instruuje fałszywe timery, aby wyczyściły timery "natywne" (tj. niefałszywe), delegując je do 相应的 handlerów. Gdy ta opcja jest wyłączona, może to prowadzić do potencjalnie nieoczekiwanego zachowania, jeśli timery istniały przed rozpoczęciem sesji fałszywych timerów.

workspace*

Typ: string
CLI: --workspace=./file.js
Domyślnie: vitest.{workspace,projects}.{js,ts,json} w pobliżu pliku konfiguracyjnego lub korzenia projektu

Ścieżka do pliku konfiguracyjnego przestrzeni roboczej, relatywna do root.

isolate

Typ: boolean
Domyślnie: true
CLI: --no-isolate, --isolate=false

Uruchamia testy w izolowanym środowisku. Ta opcja nie ma wpływu na pule vmThreads i vmForks.

Wyłączenie tej opcji może zwiększyć wydajność, jeśli kod nie wykorzystuje efektów ubocznych (co zazwyczaj ma miejsce w projektach działających w środowisku node).

TIP

Możesz wyłączyć izolację dla określonych pul za pomocą właściwości poolOptions.

includeTaskLocation

Typ: boolean
Domyślnie: false

Określa, czy dołączać właściwość location, gdy API Vitest otrzymuje zadania w reporterach. Jeśli masz dużo testów, może to spowodować niewielką regresję wydajności.

Właściwość location zawiera wartości column i line, które odpowiadają pozycji test lub describe w oryginalnym pliku.

Ta opcja zostanie automatycznie włączona, jeśli jej jawnie nie wyłączysz i uruchamiasz Vitest w następujący sposób:

Vitest UI
lub korzystając z Trybu przeglądarki bez trybu headless
lub korzystając z Raportu HTML

TIP

Ta opcja nie ma wpływu, jeśli nie używasz niestandardowego kodu, który z niej korzysta.

snapshotEnvironment

Typ: string

Ścieżka do niestandardowej implementacji środowiska snapshotów. Jest to przydatne, jeśli uruchamiasz testy w środowisku, które nie obsługuje API Node.js. Ta opcja nie ma wpływu na runner przeglądarki.

Ten obiekt powinien implementować interfejs SnapshotEnvironment i jest używany do rozwiązywania i odczytu/zapisu plików snapshotów:

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

Możesz rozszerzyć domyślny VitestSnapshotEnvironment z punktu wejścia vitest/snapshot, jeśli potrzebujesz nadpisać tylko część API.

WARNING

Jest to opcja niskopoziomowa, przeznaczona do użycia w zaawansowanych przypadkach, gdy dostęp do domyślnych API Node.js jest ograniczony.

Jeśli potrzebujesz tylko skonfigurować funkcję snapshotów, użyj opcji snapshotFormat lub resolveSnapshotPath.

env

Typ: Partial<NodeJS.ProcessEnv>

Zmienne środowiskowe dostępne w process.env i import.meta.env podczas testów. Zmienne te nie będą dostępne w głównym procesie (np. w globalSetup).

expect

Typ: ExpectOptions

expect.requireAssertions

Typ: boolean
Domyślnie: false

To samo, co wywołanie expect.hasAssertions() na początku każdego testu. Zapewnia to, że żaden test nie przejdzie losowo.

TIP

Działa to tylko z obiektem expect Vitest. Jeśli używasz asercji assert lub .should, nie będą one liczone, a test zakończy się niepowodzeniem z powodu braku asercji expect.

Możesz zmienić wartość tego pola, wywołując vi.setConfig({ expect: { requireAssertions: false } }). Konfiguracja zostanie zastosowana do każdego kolejnego wywołania expect aż do ręcznego wywołania vi.resetConfig.

expect.poll

Globalne opcje konfiguracji dla expect.poll. Są to te same opcje, które można przekazać do expect.poll(condition, options).

expect.poll.interval

Typ: number
Domyślnie: 50

Interwał odpytywania w milisekundach

expect.poll.timeout

Typ: number
Domyślnie: 1000

Limit czasu odpytywania w milisekundach

printConsoleTrace

Typ: boolean
Domyślnie: false

Zawsze drukuje ślady konsoli podczas wywoływania dowolnej metody console. Jest to przydatne do debugowania.

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

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