Vitest konfigurálása

A Vitest konfigurációs fájl létrehozásához kövesse az útmutatót. Mielőtt továbblépne, győződjön meg róla, hogy megértette a Vitest konfiguráció feloldásának működését.

WARNING

Minden itt felsorolt opció a konfiguráción belül egy test tulajdonságon található:

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

TIP

A következő opciók mellett bármilyen konfigurációs opciót használhat a Vite-ből. Például a define globális változók definiálásához, vagy a resolve.alias aliasok definiálásához.

Minden konfigurációs opció, amely nem támogatott egy munkaterület projekt konfigurációjában, * jelzéssel van ellátva.

include

Típus: string[]
Alapértelmezett: ['**/*.{test,spec}.?(c|m)[jt]s?(x)']
CLI: vitest [...include], vitest **/*.test.js

Glob minták listája, amelyek illeszkednek a tesztfájlokhoz.

exclude

Típus: string[]
Alapértelmezett: ['**/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"

Glob minták listája, amelyek kizárásra kerülnek a tesztfájlok közül.

WARNING

Ez az opció nincs hatással a lefedettségre. Ha el kell távolítania bizonyos fájlokat a lefedettségi jelentésből, használja a coverage.exclude opciót.

Ez az egyetlen opció, amely nem írja felül a konfigurációt, ha CLI kapcsolóval adja meg. A --exclude flag-gel hozzáadott összes glob minta hozzá lesz adva a konfiguráció exclude listájához.

includeSource

Típus: string[]
Alapértelmezett: []

Glob minták a forráskódba ágyazott tesztfájlokhoz.

Ha definiálva van, a Vitest az összes egyező fájlt futtatja, amelyben import.meta.vitest található.

server 0.34.0+

Típus: { sourcemap?, deps?, ... }

Vite-Node szerver opciók.

server.sourcemap

Típus: 'inline' | boolean
Alapértelmezett: 'inline'

Inline sourcemap beillesztése a modulokba.

server.debug

Típus: { dumpModules?, loadDumppedModules? }

Vite-Node debugger opciók.

server.debug.dumpModules

Típus: boolean | string

A transzformált modul elmentése a fájlrendszerbe. Ha stringet ad meg, a megadott útvonalra menti.

server.debug.loadDumppedModules

Típus: boolean

A mentett modul betöltése a fájlrendszerből, ha az létezik. Hasznos a hibakereséshez a mentett eredmény fájlrendszerből történő módosításával.

server.deps

Típus: { external?, inline?, ... }

Függőségek feloldásának kezelése.

server.deps.external

Típus: (string | RegExp)[]
Alapértelmezett: [/\/node_modules\//]

Az externalizálás azt jelenti, hogy a Vite megkerüli a csomagot a natív Node irányába. Az externalizált függőségekre nem vonatkoznak a Vite transzformátorai és feloldói, így nem támogatják a HMR-t az újratöltéskor. Alapértelmezés szerint a node_modules mappában lévő összes csomag externalizálva van.

Ezek az opciók támogatják a csomagneveket, ahogyan a node_modules mappában vannak írva, vagy ahogyan a deps.moduleDirectories belsejében meg vannak adva. Például a packages/some-name mappában található @company/some-name csomagot some-name néven kell megadni, és a packages mappát bele kell foglalni a deps.moduleDirectories listájába. Alapvetően a Vitest mindig a fájl elérési útját ellenőrzi, nem a tényleges csomagnevet.

Ha reguláris kifejezést használ, a Vitest a fájl elérési útját veszi figyelembe, nem a csomagnevet.

server.deps.inline

Típus: (string | RegExp)[] | true
Alapértelmezett: []

A Vite feldolgozza a beágyazott modulokat. Ez hasznos lehet olyan csomagok kezeléséhez, amelyek .js fájlokat szállítanak ESM formátumban (amelyet a Node nem tud kezelni).

Ha true, akkor minden függőség beágyazott lesz. A ssr.noExternal fájlban megadott összes függőség alapértelmezés szerint beágyazott lesz.

server.deps.fallbackCJS

Típus boolean
Alapértelmezett: false

Amennyiben egy függőség érvényes ESM csomag, a rendszer megpróbálja kitalálni a CJS verzióját az elérési út alapján. Ez hasznos lehet, ha egy függőségnek hibás ESM fájlja van.

Ez potenciálisan eltéréseket okozhat, ha egy csomagnak eltérő logikája van ESM és CJS módban.

server.deps.cacheDir

Típus string
Alapértelmezett: 'node_modules/.vite'

A gyorsítótár fájlok tárolásának könyvtára.

deps

Típus: { optimizer?, ... }

Függőségek feloldásának kezelése.

deps.optimizer 0.34.0+

Típus: { ssr?, web? }
Lásd még: Dep Optimization Options

Függőség optimalizálás engedélyezése. Ha sok tesztje van, ez javíthatja a teljesítményüket. A Vitest 0.34.0 előtt deps.experimentalOptimizer néven szerepelt.

Amikor a Vitest találkozik az include listában szereplő külső könyvtárral, egyetlen fájlba kötegelve lesz az esbuild segítségével, és egyetlen modulként lesz importálva. Ez több okból is jó:

A sok importtal rendelkező csomagok importálása költséges. Ha egy fájlba kötegeljük őket, sok időt takaríthatunk meg.
A felhasználói felület könyvtárainak importálása költséges, mivel azok nem Node.js környezetben való futtatásra lettek tervezve.
Az alias konfiguráció a kötegelt csomagokon belül mostantól érvényesül.
A tesztekben futó kód jobban hasonlít a böngészőben futó kódhoz.

Vegye figyelembe, hogy csak a deps.optimizer?.[mode].include opcióban szereplő csomagok vannak kötegelve (egyes bővítmények automatikusan feltöltik ezt, például a Svelte). További információkat a Vite dokumentációjában talál (a Vitest nem támogatja a disable és a noDiscovery opciókat). Alapértelmezés szerint a Vitest az optimizer.web opciót használja a jsdom és a happy-dom környezetekhez, az optimizer.ssr opciót pedig a node és az edge környezetekhez, de ez a transformMode segítségével konfigurálható.

Ez az opció örökli az optimizeDeps konfigurációt is (a webes Vitest kiterjeszti az optimizeDeps konfigurációt, míg az ssr az ssr.optimizeDeps konfigurációt). Ha újradefiniálja az include/exclude opciót a deps.optimizer fájlban, az kiterjeszti az optimizeDeps fájlt a tesztek futtatásakor. A Vitest automatikusan eltávolítja ugyanazokat az opciókat az include fájlból, ha szerepelnek az exclude fájlban.

TIP

Nem fogja tudni szerkeszteni a node_modules kódot a hibakereséshez, mivel a kód valójában a cacheDir vagy a test.cache.dir könyvtárban található. Ha console.log utasításokkal szeretne hibakeresést végezni, szerkessze közvetlenül, vagy kényszerítse ki az újrakötegelést a deps.optimizer?.[mode].force opcióval.

deps.optimizer.{mode}.enabled

Típus: boolean
Alapértelmezett: false a Vitest 1.3.0 óta

Függőség optimalizálás engedélyezése.

WARNING

Ez az opció csak a Vite 4.3.2 és újabb verziókkal működik.

deps.web 0.34.2+

Típus: { transformAssets?, ... }

Olyan opciók, amelyek a külső fájlokra vonatkoznak, amennyiben a transzformációs mód web értékre van állítva. Alapértelmezés szerint a jsdom és a happy-dom a web módot használja, míg a node és az edge környezetek az ssr transzformációs módot használják, így ezek az opciók nem befolyásolják a fájlokat ezekben a környezetekben.

Általában a node_modules mappában lévő fájlok externalizálva vannak, de ezek az opciók a server.deps.external fájlokra is hatással vannak.

deps.web.transformAssets

Típus: boolean
Alapértelmezett: true

A Vitest feldolgozza az eszközfájlokat (.png, .svg, .jpg stb.), és feloldja őket úgy, ahogy a Vite a böngészőben.

Ez a modul egy alapértelmezett exporttal rendelkezik, ami megegyezik az eszköz elérési útjával, amennyiben nincs lekérdezés megadva.

WARNING

Jelenleg ez az opció csak a vmThreads és a vmForks poolokkal működik.

deps.web.transformCss

Típus: boolean
Alapértelmezett: true

A Vitest a CSS (.css, .scss, .sass stb.) fájlokat a Vite böngészőben megszokott módján dolgozza fel és oldja fel.

Ha a CSS fájlok le vannak tiltva a css opciókkal, ez az opció csupán az ERR_UNKNOWN_FILE_EXTENSION hibákat némítja el.

WARNING

Jelenleg ez az opció csak a vmThreads és a vmForks poolokkal működik.

deps.web.transformGlobPattern

Típus: RegExp | RegExp[]
Alapértelmezett: []

Regexp minta a transzformálandó külső fájlokhoz.

Alapértelmezés szerint a node_modules mappában lévő fájlok externalizálva vannak, és nincsenek transzformálva, kivéve, ha CSS vagy eszköz, és a megfelelő opció nincs letiltva.

WARNING

Jelenleg ez az opció csak a vmThreads és a vmForks poolokkal működik.

deps.interopDefault

Típus: boolean
Alapértelmezett: true

A CJS modul alapértelmezett értelmezése név szerinti exportként. Egyes függőségek csak CJS modulokat kötegelnek, és nem használnak névvel ellátott exportokat, amelyeket a Node.js statikusan elemezhet, amikor egy csomagot import szintaxissal importálnak a require helyett. Ha ilyen függőségeket importál Node környezetben névvel ellátott exportok használatával, a következő hibaüzenet jelenik meg:

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.

A Vitest nem végez statikus elemzést, és nem tud meghiúsulni a kód futtatása előtt, így valószínűleg ezt a hibát fogja tapasztalni a tesztek futtatásakor, ha ez a funkció le van tiltva:

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

Alapértelmezés szerint a Vitest feltételezi, hogy kötegelőt használ ennek megkerülésére, és nem fog meghiúsulni, de manuálisan letilthatja ezt a viselkedést, ha a kód nincs feldolgozva.

deps.moduleDirectories

Típus: string[]
Alapértelmezett: ['node_modules']

A modulkönyvtárként kezelendő könyvtárak listája. Ez a konfigurációs opció befolyásolja a vi.mock viselkedését: ha nincs megadva gyár, és a mockolt elem elérési útja megegyezik a moduleDirectories értékek egyikével, a Vitest megpróbálja feloldani a mockot egy __mocks__ mappa keresésével a projekt gyökerében.

Ez az opció azt is befolyásolja, hogy egy fájlt modulként kell-e kezelni a függőségek externalizálásakor. Alapértelmezés szerint a Vitest natív Node.js-sel importálja a külső modulokat, megkerülve a Vite transzformációs lépését.

Ennek az opciónak a beállítása felülírja az alapértelmezettet. Amennyiben továbbra is a node_modules mappában szeretne csomagokat keresni, adja hozzá a többi opcióval együtt:

import { defineConfig } from 'vitest/config';

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

runner

Típus: VitestRunnerConstructor
Alapértelmezett: node, tesztek futtatásakor, vagy benchmark, benchmarkok futtatásakor

Egyéni tesztfuttató elérési útja. Ez egy haladó funkció, és egyéni könyvtárfuttatókkal kell használni. További információkat a dokumentációban talál.

benchmark

Típus: { include?, exclude?, ... }

A vitest bench futtatásakor használt opciók.

benchmark.include

Típus: string[]
Alapértelmezett: ['**/*.{bench,benchmark}.?(c|m)[jt]s?(x)']

Glob minták a benchmark tesztfájlokhoz.

benchmark.exclude

Típus: string[]
Alapértelmezett: ['node_modules', 'dist', '.idea', '.git', '.cache']

Glob minták a benchmark tesztfájlok kizárásához.

benchmark.includeSource

Típus: string[]
Alapértelmezett: []

Glob minták a forráskódba ágyazott benchmark tesztfájlokhoz. Ez az opció hasonló a includeSource opcióhoz.

Ha definiálva van, a Vitest az összes egyező fájlt futtatja, amelyben import.meta.vitest található.

benchmark.reporters

Típus: Arrayable<BenchmarkBuiltinReporters | Reporter>
Alapértelmezett: 'default'

Egyéni riporter a kimenethez. Tartalmazhat egy vagy több beépített jelentésnevet, riporter példányt és/vagy egyéni riporterek elérési útját.

benchmark.outputFile

Típus: string | Record<string, string>

A benchmark eredmények fájlba mentése, ha a --reporter=json opció is meg van adva. Ha string helyett objektumot ad meg, egyéni kimeneteket definiálhat több riporter használatakor.

Objektum megadásához a CLI parancson keresztül használja a következő szintaxist: --outputFile.json=./path --outputFile.junit=./other-path.

benchmark.outputJson 1.6.0+

Típus: string | undefined
Alapértelmezett: undefined

A benchmark eredmény mentésének fájl elérési útja, amely később a --compare opcióhoz használható.

Például:

# a main ág eredményének mentése
git checkout main
vitest bench --outputJson main.json

# ág váltása és összehasonlítás a main ággal
git checkout feature
vitest bench --compare main.json

benchmark.compare 1.6.0+

Típus: string | undefined
Alapértelmezett: undefined

Egy korábbi benchmark eredmények fájl elérési útja, amellyel összehasonlíthatja az aktuális futtatásokat.

alias

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

Egyéni aliasok definiálása a teszteken belüli futtatáshoz. Ezek egyesítve lesznek a resolve.alias aliasaival.

WARNING

A Vitest a Vite SSR alapfunkcióit használja a tesztek futtatásához, amelyeknek bizonyos buktatói vannak.

Az aliasok csak azokra a modulokra vonatkoznak, amelyeket közvetlenül egy inline modul importál az import kulcsszóval (alapértelmezés szerint minden forráskód inline).
A Vitest nem támogatja a require hívások aliasolását.
Külső függőség aliasolása esetén (pl. react -> preact) érdemes lehet a tényleges node_modules csomagokat aliasolni, hogy az externalizált függőségekkel is működjön. A Yarn és a pnpm is támogatja az aliasolást az npm: előtaggal.

globals

Típus: boolean
Alapértelmezett: false
CLI: --globals, --globals=false

Alapértelmezés szerint a vitest nem biztosít globális API-kat a kifejezőképesség érdekében. Ha inkább globálisan szeretné használni az API-kat, mint a Jest, átadhatja a --globals opciót a CLI-nek, vagy hozzáadhatja a globals: true értéket a konfigurációban.

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

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

A TypeScript globális API-kkal való működéséhez adja hozzá a vitest/globals fájlt a tsconfig.json fájl types mezőjéhez.

json

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

Ha már használja az unplugin-auto-import csomagot a projektben, akkor közvetlenül is használhatja az API-k automatikus importálásához.

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

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

environment

Típus: 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime' | string
Alapértelmezett: 'node'
CLI: --environment=<env>

A tesztek futtatásához használt környezet. A Vitest alapértelmezett környezete a Node.js. Ha webalkalmazást fejleszt, böngésző-szerű környezetet használhat a jsdom vagy a happy-dom segítségével. Edge függvények fejlesztéséhez használhatja az edge-runtime környezetet is.

Egy @vitest-environment docblock vagy komment hozzáadásával a fájl tetején megadhat egy másik környezetet, amelyet az adott fájlban lévő összes teszthez használni kell:

Docblock stílus:

/**
 * @vitest-environment jsdom
 */

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

Komment stílus:

// @vitest-environment happy-dom

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

A Jest-tel való kompatibilitás érdekében a @jest-environment is használható:

/**
 * @jest-environment jsdom
 */

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

Ha a Vitest-et a --isolate=false kapcsolóval futtatja, a tesztek ebben a sorrendben futnak: node, jsdom, happy-dom, edge-runtime, custom environments. Ez azt jelenti, hogy az azonos környezetű tesztek csoportosítva lesznek, de továbbra is szekvenciálisan futnak.

A 0.23.0-tól kezdve egyéni környezet is definiálható. Ha nem beépített környezetet használ, a Vitest megpróbálja betölteni a vitest-environment-${name} csomagot. Ennek a csomagnak egy Environment típusú objektumot kell exportálnia:

import type { Environment } from 'vitest';

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

A Vitest a vitest/environments bejegyzésen keresztül elérhetővé teszi a builtinEnvironments-et is, ha csak ki szeretné bővíteni azt. A környezetek bővítéséről útmutatónkban olvashat bővebben.

TIP

A Vitest 1.3.0 óta a jsdom környezet elérhetővé teszi a jsdom globális változót, amely megegyezik az aktuális JSDOM példánnyal. Ha azt szeretné, hogy a TypeScript felismerje, hozzáadhatja a vitest/jsdom-ot a tsconfig.json fájljához, amikor ezt a környezetet használja:

json

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

environmentOptions

Típus: Record<'jsdom' | string, unknown>
Alapértelmezett: {}

Ezek az opciók az aktuális environment setup metódusának kerülnek átadásra. Alapértelmezés szerint csak a JSDOM opcióit konfigurálhatja, ha azt használja tesztkörnyezetként.

environmentMatchGlobs

Típus: [string, EnvironmentName][]
Alapértelmezett: []

Automatikusan hozzárendeli a környezetet a globok alapján. Az első találat kerül felhasználásra.

Például:

import { defineConfig } from 'vitest/config';

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

poolMatchGlobs 0.29.4+

Típus: [string, 'threads' | 'forks' | 'vmThreads' | 'vmForks' | 'typescript'][]
Alapértelmezett: []

Automatikusan hozzárendeli a készletet, amelyben a tesztek a globok alapján futnak. Az első találat kerül felhasználásra.

Például:

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*

Típus: boolean
Alapértelmezett: false
CLI: -u, --update, --update=false

Pillanatkép fájlok frissítése. Ez frissíti az összes megváltozott pillanatképet, és törli az elavultakat.

watch*

Típus: boolean
Alapértelmezett: !process.env.CI
CLI: -w, --watch, --watch=false

Figyelő mód engedélyezése.

root

Típus: string
CLI: -r <path>, --root=<path>

Projekt gyökérkönyvtára.

reporters*

Típus: Reporter | Reporter[]
Alapértelmezett: 'default'
CLI: --reporter=<name>, --reporter=<name1> --reporter=<name2>

Egyéni jelentéskészítők a kimenethez. A riporterek lehetnek Reporter példányok, egy karakterlánc a beépített riporterek kiválasztásához, vagy egy elérési út egy egyéni implementációhoz (pl. './path/to/reporter.ts', '@scope/reporter').

outputFile*

Típus: string | Record<string, string>
CLI: --outputFile=<path>, --outputFile.json=./path

A teszteredmények fájlba íródnak, ha a --reporter=json, --reporter=html vagy --reporter=junit opció is meg van adva. Ha egy karakterlánc helyett egy objektumot ad meg, egyedi kimeneteket definiálhat, ha több riportert használ.

pool* 1.0.0+

Típus: 'threads' | 'forks' | 'vmThreads' | 'vmForks'
Alapértelmezett: 'threads'
CLI: --pool=threads

A tesztek futtatásához használt készlet.

threads*

Többszálúság engedélyezése a tinypool használatával (a Piscina könnyűsúlyú forkja). Szálak használatakor nem használhat olyan folyamatokkal kapcsolatos API-kat, mint a process.chdir(). Néhány natív nyelven írt könyvtár, mint például a Prisma, a bcrypt és a canvas, problémákba ütközik, ha több szálon fut, és segfaultokba fut. Ezekben az esetekben ajánlott a forks készlet használata helyette.

forks*

Hasonló a threads készlethez, de a worker_threads helyett a child_process-t használja a tinypool segítségével. A tesztek és a fő folyamat közötti kommunikáció nem olyan gyors, mint a threads készletnél. A folyamatokkal kapcsolatos API-k, mint például a process.chdir(), elérhetők a forks készletben.

vmThreads*

A teszteket a VM context (egy sandbox környezetben) használatával futtatja egy threads készletben.

Ez felgyorsítja a tesztek futását, de a VM modul instabil lehet, ha ESM kódot futtat. A tesztek memóriaszivárgást okozhatnak - ennek elkerülése érdekében fontolja meg a poolOptions.vmThreads.memoryLimit értékének manuális beállítását.

WARNING

A kód sandboxban való futtatásának van néhány előnye (gyorsabb tesztek), de számos hátránya is van.

A natív modulokon belüli globálisok, mint például (fs, path stb.), eltérnek a tesztkörnyezetben jelenlévő globálisoktól. Ennek eredményeként az ezen natív modulok által dobott hibák egy másik Error konstruktorra hivatkoznak, mint a kódban használt:

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

Az ES modulok importálása határozatlan ideig gyorsítótárazza őket, ami memóriaszivárgást okoz, ha sok kontextusa (tesztfájlja) van. A Node.js-ben nincs olyan API, amely törli ezt a gyorsítótárat.
A globálisok elérése tovább tart egy sandbox környezetben.

Kérjük, vegye figyelembe ezeket a problémákat, amikor ezt az opciót használja. A Vitest csapata nem tudja kijavítani a problémákat a mi oldalunkon.

vmForks*

Hasonló a vmThreads készlethez, de a worker_threads helyett a child_process-t használja a tinypool segítségével. A tesztek és a fő folyamat közötti kommunikáció nem olyan gyors, mint a vmThreads készletnél. A folyamatokkal kapcsolatos API-k, mint például a process.chdir(), elérhetők a vmForks készletben. Kérjük, vegye figyelembe, hogy ez a készlet ugyanazokkal a buktatókkal rendelkezik, mint a vmThreads.

poolOptions* 1.0.0+

Típus: Record<'threads' | 'forks' | 'vmThreads' | 'vmForks', {}>
Alapértelmezett: {}

poolOptions.threads

Opciók a threads készlethez.

import { defineConfig } from 'vitest/config';

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

poolOptions.threads.maxThreads*

Típus: number
Alapértelmezett: elérhető CPU-k száma

Maximális szálak száma. Használhatja a VITEST_MAX_THREADS környezeti változót is.

poolOptions.threads.minThreads*

Típus: number
Alapértelmezett: elérhető CPU-k száma

Minimális szálak száma. Használhatja a VITEST_MIN_THREADS környezeti változót is.

poolOptions.threads.singleThread

Típus: boolean
Alapértelmezett: false

Futtassa az összes tesztet ugyanabban a környezetben, egyetlen worker szálban. Ez letiltja a beépített modul izolációt (a forráskód vagy az inline kód továbbra is újraértékelésre kerül minden teszthez), de javíthatja a teszt teljesítményét.

WARNING

Bár ez az opció arra kényszeríti a teszteket, hogy egymás után fussanak, ez az opció eltér a Jest --runInBand opciójától. A Vitest nem csak a tesztek párhuzamos futtatására használ workereket, hanem az izoláció biztosítására is. Az opció letiltásával a tesztek szekvenciálisan futnak, de ugyanabban a globális kontextusban, ezért az izolációt magának kell biztosítania.

Ez mindenféle problémát okozhat, ha globális állapotra támaszkodik (a frontend keretrendszerek általában ezt teszik), vagy a kódja arra támaszkodik, hogy a környezet minden teszthez külön legyen definiálva. De ez egy sebességnövelő lehet a tesztekhez (akár 3-szor gyorsabb), amelyek nem feltétlenül támaszkodnak globális állapotra, vagy könnyen megkerülhetik azt.

poolOptions.threads.useAtomics*

Típus: boolean
Alapértelmezett: false

Használja az Atomics-ot a szálak szinkronizálásához.

Ez bizonyos esetekben javíthatja a teljesítményt, de régebbi Node verziókban segfaultot okozhat.

poolOptions.threads.isolate

Típus: boolean
Alapértelmezett: true

Környezet izolálása minden tesztfájlhoz.

poolOptions.threads.execArgv*

Típus: string[]
Alapértelmezett: []

További argumentumokat ad át a node-nak a szálakban. További információkért lásd: Command-line API | Node.js.

WARNING

Legyen óvatos a használatával, mivel néhány opció összeomolhatja a workert, pl. --prof, --title. Lásd: https://github.com/nodejs/node/issues/41103.

poolOptions.forks

Opciók a forks készlethez.

import { defineConfig } from 'vitest/config';

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

poolOptions.forks.maxForks*

Típus: number
Alapértelmezett: elérhető CPU-k száma

Maximális elágazások száma.

poolOptions.forks.minForks*

Típus: number
Alapértelmezett: elérhető CPU-k száma

Minimális elágazások száma.

poolOptions.forks.isolate

Típus: boolean
Alapértelmezett: true

Környezet izolálása minden tesztfájlhoz.

poolOptions.forks.singleFork

Típus: boolean
Alapértelmezett: false

Futtassa az összes tesztet ugyanabban a környezetben, egyetlen gyermekfolyamatban. Ez letiltja a beépített modul izolációt (a forráskód vagy az inline kód továbbra is újraértékelésre kerül minden teszthez), de javíthatja a teszt teljesítményét.

WARNING

Bár ez az opció arra kényszeríti a teszteket, hogy egymás után fussanak, ez az opció eltér a Jest --runInBand opciójától. A Vitest nem csak a tesztek párhuzamos futtatására használ gyermekfolyamatokat, hanem az izoláció biztosítására is. Az opció letiltásával a tesztek szekvenciálisan futnak, de ugyanabban a globális kontextusban, ezért az izolációt magának kell biztosítania.

poolOptions.forks.execArgv*

Típus: string[]
Alapértelmezett: []

További argumentumokat ad át a node folyamatnak a gyermekfolyamatokban. További információkért lásd: Command-line API | Node.js.

WARNING

Legyen óvatos a használatával, mivel néhány opció összeomolhatja a workert, pl. --prof, --title. Lásd: https://github.com/nodejs/node/issues/41103.

poolOptions.vmThreads

Opciók a vmThreads készlethez.

import { defineConfig } from 'vitest/config';

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

poolOptions.vmThreads.maxThreads*

Típus: number
Alapértelmezett: elérhető CPU-k száma

Maximális szálak száma. Használhatja a VITEST_MAX_THREADS környezeti változót is.

poolOptions.vmThreads.minThreads*

Típus: number
Alapértelmezett: elérhető CPU-k száma

Minimális szálak száma. Használhatja a VITEST_MIN_THREADS környezeti változót is.

poolOptions.vmThreads.memoryLimit*

Típus: string | number
Alapértelmezett: 1 / CPU Cores

Megadja a munkavállalók memóriakorlátját, mielőtt újrahasznosítják őket. Ez az érték nagymértékben függ a környezetétől, ezért jobb, ha manuálisan adja meg, ahelyett, hogy az alapértelmezettre támaszkodna.

TIP

Az implementáció a Jest workerIdleMemoryLimit alapján készült.

A korlát többféleképpen megadható, de a végeredmény a Math.floor használatával egész számmá lesz alakítva:

<= 1 - Az érték a rendszermemória százalékának tekintendő. Tehát a 0,5 a munkavállaló memóriakorlátját a teljes rendszermemória felére állítja.
\> 1 - Fix bájtértéknek tekintendő. Az előző szabály miatt, ha 1 bájtos értéket szeretne (nem tudom miért), használhatna 1,1-et.
Mértékegységekkel
- 50% - Mint fent, a teljes rendszermemória százaléka
- 100KB, 65MB stb. - Mértékegységekkel a fix memóriakorlát jelzésére.
  - K / KB - Kilobájt (×1000)
  - KiB - Kibibájt (×1024)
  - M / MB - Megabájt
  - MiB - Mebibájt
  - G / GB - Gigabájt
  - GiB - Gibibájt

WARNING

A százalékos alapú memóriakorlát nem működik a Linux CircleCI munkavállalókon, mert helytelen rendszermemóriát jelentenek.

poolOptions.vmThreads.useAtomics*

Típus: boolean
Alapértelmezett: false

Használja az Atomics-ot a szálak szinkronizálásához.

Ez bizonyos esetekben javíthatja a teljesítményt, de régebbi Node verziókban segfaultot okozhat.

poolOptions.vmThreads.execArgv*

Típus: string[]
Alapértelmezett: []

További argumentumokat ad át a node folyamatnak a VM kontextusban. További információkért lásd: Command-line API | Node.js.

WARNING

Legyen óvatos a használatával, mivel néhány opció összeomolhatja a workert, pl. --prof, --title. Lásd: https://github.com/nodejs/node/issues/41103.

poolOptions.vmForks

Opciók a vmForks készlethez.

import { defineConfig } from 'vitest/config';

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

poolOptions.vmForks.maxForks*

Típus: number
Alapértelmezett: elérhető CPU-k száma

Maximális szálak száma. Használhatja a VITEST_MAX_FORKS környezeti változót is.

poolOptions.vmForks.minForks*

Típus: number
Alapértelmezett: elérhető CPU-k száma

Minimális szálak száma. Használhatja a VITEST_MIN_FORKS környezeti változót is.

poolOptions.vmForks.memoryLimit*

Típus: string | number
Alapértelmezett: 1 / CPU Cores

poolOptions.vmForks.execArgv*

Típus: string[]
Alapértelmezett: []

További argumentumokat ad át a node folyamatnak a VM kontextusban. További információkért lásd: Command-line API | Node.js.

WARNING

Legyen óvatos a használatával, mivel néhány opció összeomolhatja a workert, pl. --prof, --title. Lásd: https://github.com/nodejs/node/issues/41103.

fileParallelism 1.1.0+

Típus: boolean
Alapértelmezett: true
CLI: --no-file-parallelism, --fileParallelism=false

A tesztfájlok futtathatók-e párhuzamosan? Ha ezt false értékre állítja, az felülírja a maxWorkers és minWorkers opciókat 1-re.

TIP

Ez az opció nem befolyásolja ugyanabban a fájlban futó teszteket. Ha azokat párhuzamosan szeretné futtatni, használja a concurrent opciót a describe függvényen, vagy egy konfiguráción keresztül.

maxWorkers 1.1.0+

Típus: number

A tesztek futtatásához használható maximális számú worker. A poolOptions.{threads,vmThreads}.maxThreads/poolOptions.forks.maxForks beállítások prioritása magasabb.

minWorkers 1.1.0+

Típus: number

A tesztek futtatásához használható minimális számú worker. A poolOptions.{threads,vmThreads}.minThreads/poolOptions.forks.maxForks beállítások prioritása magasabb.

testTimeout

Típus: number
Alapértelmezett: 5000
CLI: --test-timeout=5000, --testTimeout=5000

Egy teszt alapértelmezett időtúllépése ezredmásodpercben.

hookTimeout

Típus: number
Alapértelmezett: 10000
CLI: --hook-timeout=10000, --hookTimeout=10000

Egy hook alapértelmezett időtúllépése ezredmásodpercben.

teardownTimeout*

Típus: number
Alapértelmezett: 10000
CLI: --teardown-timeout=5000, --teardownTimeout=5000

A Vitest leállásakor a leállításra való várakozás alapértelmezett időtúllépése ezredmásodpercben.

silent*

Típus: boolean
Alapértelmezett: false
CLI: --silent, --silent=false

A tesztek konzolkimenetének elnémítása.

setupFiles

Típus: string | string[]

A beállítófájlok elérési útvonala. Ezek minden tesztfájl előtt lefutnak.

INFO

A beállítófájlok módosítása kiváltja az összes teszt újrafuttatását.

A process.env.VITEST_POOL_ID (egész számot tartalmazó string) használatával megkülönböztetheti a szálakat.

TIP

Ne feledje, hogy ha a --isolate=false opciót használja, ez a beállítófájl többször is lefut ugyanabban a globális scope-ban. Ez azt jelenti, hogy minden teszt előtt ugyanazt a globális objektumot éri el, ezért ügyeljen arra, hogy ne hajtsa végre ugyanazt a műveletet többször, mint szükséges.

Például támaszkodhat egy globális változóra:

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

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

// A hook-ok minden suite előtt visszaállnak.
afterEach(() => {
  cleanup();
});

globalThis.resetBeforeEachTest = true;

globalSetup

Típus: string | string[]

Útvonal a globális beállítófájlokhoz, a projekt gyökeréhez viszonyítva.

Egy globális beállítófájl exportálhat setup és teardown nevű függvényeket, vagy egy default függvényt, amely egy leállító függvényt ad vissza (példa).

INFO

Több globális beállítófájl is használható. A setup és a teardown szekvenciálisan futnak, a teardown fordított sorrendben.

WARNING

A Vitest 1.0.0-beta verzió óta a globális beállítás csak akkor fut, ha legalább egy teszt fut. Ez azt jelenti, hogy a globális beállítás a figyelő módban a tesztfájl módosítása után kezdhet el futni (a tesztfájl megvárja, amíg a globális beállítás befejeződik, mielőtt lefut).

Ne feledje, hogy a globális beállítás egy másik globális scope-ban fut, így a tesztek nem érik el az itt definiált változókat. Azonban az 1.0.0 verziótól kezdve szerializálható adatokat adhat át a teszteknek a provide metóduson keresztül:

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

// Kibővítheti a `ProvidedContext` típust is
// a `provide/inject` metódusok típusbiztos eléréséhez:
declare module 'vitest' {
  export interface ProvidedContext {
    wsPort: number;
  }
}

import { inject } from 'vitest';

inject('wsPort') === 3000;

watchExclude*

Típus: string[]
Alapértelmezett: ['**/node_modules/**', '**/dist/**']
Elavult: használja a server.watch.ignored opciót

Glob minta a fájlútvonalakhoz, amelyeket a figyelő újrafuttatásakor figyelmen kívül kell hagyni.

forceRerunTriggers*

Típus: string[]
Alapértelmezett: ['**/package.json/**', '**/vitest.config.*/**', '**/vite.config.*/**']

Glob minta a fájlútvonalakhoz, amelyek a teljes tesztcsoport újrafuttatását váltják ki. A --changed argumentummal együtt használva a teljes tesztcsoport fut le, ha a trigger megtalálható a git diff-ben.

Hasznos, ha CLI parancsok hívását teszteli, mert a Vite nem tud modulgráfot létrehozni:

test('execute a script', async () => {
  // A Vitest nem tudja újrafuttatni ezt a tesztet, ha a `dist/index.js` tartalma megváltozik
  await execa('node', ['dist/index.js']);
});

TIP

Győződjön meg arról, hogy a fájljait nem zárja ki a watchExclude.

coverage*

A coverage gyűjtéséhez használhatja a v8, istanbul vagy egy egyéni coverage megoldást.

A coverage beállításokat a CLI-nek pont jelöléssel adhatja meg:

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

WARNING

Ha a coverage beállításokat pont jelöléssel használja, ne felejtse el megadni a --coverage.enabled beállítást. Ebben az esetben ne adjon meg --coverage beállítást.

coverage.provider

Típus: 'v8' | 'istanbul' | 'custom'
Alapértelmezett: 'v8'
CLI: --coverage.provider=<provider>

A provider segítségével kiválaszthatja a coverage gyűjtéshez használt eszközt.

coverage.enabled

Típus: boolean
Alapértelmezett: false
Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.enabled, --coverage.enabled=false

Engedélyezi a coverage gyűjtést. Felülírható a --coverage CLI beállítással.

coverage.include

Típus: string[]
Alapértelmezett: ['**']
Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.include=<path>, --coverage.include=<path1> --coverage.include=<path2>

A coverage-be bevont fájlok listája glob mintákkal.

coverage.extension

Típus: string | string[]
Alapértelmezett: ['.js', '.cjs', '.mjs', '.ts', '.mts', '.cts', '.tsx', '.jsx', '.vue', '.svelte', '.marko']
Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.extension=<extension>, --coverage.extension=<extension1> --coverage.extension=<extension2>

coverage.exclude

Típus: string[]
Alapértelmezett:

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

Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.exclude=<path>, --coverage.exclude=<path1> --coverage.exclude=<path2>

A coverage-ből kizárt fájlok listája glob mintákkal.

Ez az opció felülírja az összes alapértelmezett opciót. Bővítse ki az alapértelmezett opciókat, amikor új mintákat ad hozzá a figyelmen kívül hagyáshoz:

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

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

coverage.all

Típus: boolean
Alapértelmezett: true (a Vitest 1.0.0 óta)
Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.all, --coverage.all=false

Belefoglalja-e az összes fájlt a jelentésbe, beleértve a nem tesztelteket is?

coverage.clean

Típus: boolean
Alapértelmezett: true
Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.clean, --coverage.clean=false

A coverage eredmények törlése a tesztek futtatása előtt.

coverage.cleanOnRerun

Típus: boolean
Alapértelmezett: true
Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.cleanOnRerun, --coverage.cleanOnRerun=false

A coverage jelentés törlése a figyelő újrafuttatásakor.

coverage.reportsDirectory

Típus: string
Alapértelmezett: './coverage'
Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.reportsDirectory=<path>

WARNING

A Vitest törli ezt a könyvtárat a tesztek futtatása előtt, ha a coverage.clean engedélyezve van.

A coverage jelentés mentésének könyvtára.

Ahhoz, hogy a coverage jelentést a HTML reporter kimenetében megtekinthesse, ezt az opciót a HTML jelentés könyvtárának alkönyvtáraként kell beállítani (például ./html/coverage).

coverage.reporter

Típus: string | string[] | [string, {}][]
Alapértelmezett: ['text', 'html', 'clover', 'json']
Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.reporter=<reporter>, --coverage.reporter=<reporter1> --coverage.reporter=<reporter2>

A használandó coverage riportok listája. A reporterek részletes listáját lásd az istanbul dokumentációjában. A reporter-specifikus opciókkal kapcsolatos részletekért lásd a @types/istanbul-reporter fájlt.

A reporternek három különböző típusa van:

Egyetlen reporter: { reporter: 'html' }
Több reporter opciók nélkül: { reporter: ['html', 'json'] }

Egyetlen vagy több reporter reporter opciókkal:

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

A Vitest 1.2.0 óta egyéni coverage reportereket is átadhat. További információkért lásd a Guide - Custom Coverage Reporter című részt.

{
  reporter: [
    // Adja meg a reportert az NPM csomag nevével
    '@vitest/custom-coverage-reporter',
    ['@vitest/custom-coverage-reporter', { someOption: true }],

    // Adja meg a reportert helyi útvonallal
    '/absolute/path/to/custom-reporter.cjs',
    ['/absolute/path/to/custom-reporter.cjs', { someOption: true }],
  ];
}

A Vitest 0.31.0 óta ellenőrizheti a coverage jelentését a Vitest UI-ban: további részletekért nézze meg a Vitest UI Coverage című részt.

coverage.reportOnFailure 0.31.2+

Típus: boolean
Alapértelmezett: false (a Vitest 0.34.0 óta)
Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.reportOnFailure, --coverage.reportOnFailure=false

Coverage jelentés generálása akkor is, ha a tesztek sikertelenek.

coverage.allowExternal

Típus: boolean
Alapértelmezett: false
Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.allowExternal, --coverage.allowExternal=false

Coverage gyűjtése a projekt root könyvtárán kívüli fájlokról.

coverage.skipFull

Típus: boolean
Alapértelmezett: false
Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.skipFull, --coverage.skipFull=false

Ne mutassa azokat a fájlokat, amelyek 100%-os statement, branch és function coverage-el rendelkeznek.

coverage.thresholds

A coverage küszöbértékeinek beállításai.

coverage.thresholds.lines

Típus: number
Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.thresholds.lines=<number>

Globális küszöbérték a sorokra. További információkért lásd az istanbul dokumentációját.

coverage.thresholds.functions

Típus: number
Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.thresholds.functions=<number>

Globális küszöbérték a függvényekre. További információkért lásd az istanbul dokumentációját.

coverage.thresholds.branches

Típus: number
Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.thresholds.branches=<number>

Globális küszöbérték az ágakra. További információkért lásd az istanbul dokumentációját.

coverage.thresholds.statements

Típus: number
Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.thresholds.statements=<number>

Globális küszöbérték a statementekre. További információkért lásd az istanbul dokumentációját.

coverage.thresholds.perFile

Típus: boolean
Alapértelmezett: false
Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.thresholds.perFile, --coverage.thresholds.perFile=false

Küszöbértékek ellenőrzése fájlonként.

coverage.thresholds.autoUpdate

Típus: boolean
Alapértelmezett: false
Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.thresholds.autoUpdate=<boolean>

Frissítse a lines, functions, branches és statements küszöbértékeit a konfigurációs fájlban, ha az aktuális coverage meghaladja a beállított küszöbértékeket. Ez az opció segít fenntartani a küszöbértékeket, amikor a coverage javul.

coverage.thresholds.100

Típus: boolean
Alapértelmezett: false
Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.thresholds.100, --coverage.thresholds.100=false

A globális küszöbértékeket 100-ra állítja. Rövidítés a --coverage.thresholds.lines 100 --coverage.thresholds.functions 100 --coverage.thresholds.branches 100 --coverage.thresholds.statements 100 értékhez.

coverage.thresholds[glob-pattern]

Típus: { statements?: number functions?: number branches?: number lines?: number }
Alapértelmezett: undefined
Elérhető providerekhez: 'v8' | 'istanbul'

Küszöbértékeket állít be a glob mintának megfelelő fájlokhoz.

{
  coverage: {
    thresholds: {
      // Küszöbértékek az összes fájlhoz
      functions: 95,
      branches: 70,

      // Küszöbértékek a glob mintának megfelelően
      'src/utils/**.ts': {
        statements: 95,
        functions: 90,
        branches: 85,
        lines: 80,
      },

      // Az ehhez a mintához illeszkedő fájlok csak a lines küszöbértékkel rendelkeznek.
      // A globális küszöbértékek nem öröklődnek.
      '**/math.ts': {
        lines: 100,
      }
    }
  }
}

coverage.ignoreEmptyLines

Típus: boolean
Alapértelmezett: false
Elérhető providerekhez: 'v8'
CLI: --coverage.ignoreEmptyLines=<boolean>

Hagyja figyelmen kívül az üres sorokat, a megjegyzéseket és más, nem futásidejű kódot, például a Typescript típusokat.

Ez az opció csak akkor működik, ha a használt fordító eltávolítja a megjegyzéseket és más nem futásidejű kódot a transzpilált kódból. Alapértelmezés szerint a Vite az ESBuild-et használja, amely eltávolítja a megjegyzéseket és a Typescript típusokat a .ts, .tsx és .jsx fájlokból.

Ha az ESBuild-et más fájlokra is alkalmazni szeretné, definiálja azokat az esbuild opciókban:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  esbuild: {
    // Transzpilálja az összes fájlt az ESBuild-del, hogy eltávolítsa a megjegyzéseket a coverage-ből.
    // A `test.coverage.ignoreEmptyLines` működéséhez szükséges:
    include: ['**/*.js', '**/*.jsx', '**/*.mjs', '**/*.ts', '**/*.tsx'],
  },
  test: {
    coverage: {
      provider: 'v8',
      ignoreEmptyLines: true,
    },
  },
});

coverage.ignoreClassMethods

Típus: string[]
Alapértelmezett: []
Elérhető providerekhez: 'istanbul'
CLI: --coverage.ignoreClassMethods=<method>

Állítsa be a coverage figyelmen kívül hagyandó osztálymetódusok neveinek tömbjét. További információkért lásd az istanbul dokumentációját.

coverage.watermarks

Típus:

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

Alapértelmezett:

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

Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.watermarks.statements=50,80, --coverage.watermarks.branches=50,80

Vízjelek a statementekhez, sorokhoz, ágakhoz és függvényekhez. További információkért lásd az istanbul dokumentációját.

coverage.processingConcurrency

Típus: boolean
Alapértelmezett: Math.min(20, os.availableParallelism?.() ?? os.cpus().length)
Elérhető providerekhez: 'v8' | 'istanbul'
CLI: --coverage.processingConcurrency=<number>

A coverage eredmények feldolgozásához használt párhuzamos feldolgozási korlát.

coverage.customProviderModule

Típus: string
Elérhető providerekhez: 'custom'
CLI: --coverage.customProviderModule=<path or module name>

Megadja az egyéni coverage provider modul elérési útvonalát vagy modulnevét. További információkért lásd a Guide - Custom Coverage Provider című részt.

testNamePattern*

Típus: string | RegExp
CLI: -t <minta>, --testNamePattern=<minta>, --test-name-pattern=<minta>

Azokat a teszteket futtatja, amelyek teljes neve illeszkedik a megadott mintára. Ha ezt a beállítást az OnlyRunThis értékkel kombinálja, a rendszer kihagyja azokat a teszteket, amelyek nevében nem szerepel az OnlyRunThis szó.

import { expect, test } from 'vitest';

// futtatásra kerül
test('OnlyRunThis', () => {
  expect(true).toBe(true);
});

// kihagyásra kerül
test('doNotRun', () => {
  expect(true).toBe(true);
});

open*

Típus: boolean
Alapértelmezett: !process.env.CI
CLI: --open, --open=false

Megnyitja a Vitest UI-t (fejlesztés alatt).

api

Típus: boolean | number
Alapértelmezett: false
CLI: --api, --api.port, --api.host, --api.strictPort

Figyel egy portot és kiszolgálja az API-t. Ha true értékre van állítva, az alapértelmezett port az 51204.

browser 0.29.4+

Típus: { enabled?, name?, provider?, headless?, api?, slowHijackESM? }
Alapértelmezett: { enabled: false, headless: process.env.CI, api: 63315 }
CLI: --browser, --browser=<név>, --browser.name=chrome --browser.headless

A Vitest teszteket böngészőben futtatja. Alapértelmezés szerint a WebdriverIO -t használja a tesztek futtatásához, de a browser.provider beállítással ez konfigurálható.

MEGJEGYZÉS

Tudjon meg többet a valódi böngészőben történő tesztelésről az útmutató oldalon.

WARNING

Ez egy kísérleti funkció. A kompatibilitástörő változások nem feltétlenül követik a SemVer-t, ezért javasoljuk a Vitest verziójának rögzítését a használatakor.

browser.enabled

Típus: boolean
Alapértelmezett: false
CLI: --browser, --browser.enabled=false

Alapértelmezés szerint futtatja az összes tesztet egy böngészőben. Felülírható a poolMatchGlobs beállítással.

browser.name

Típus: string
CLI: --browser=safari

Az összes tesztet egy adott böngészőben futtatja. Lehetséges opciók a különböző szolgáltatóknál:

webdriverio: firefox, chrome, edge, safari
playwright: firefox, webkit, chromium
egyéni: bármilyen karakterlánc, amely átadásra kerül a szolgáltatónak

browser.headless

Típus: boolean
Alapértelmezett: process.env.CI
CLI: --browser.headless, --browser.headless=false

A böngészőt fej nélküli (headless) módban futtatja. Ha a Vitest-et CI környezetben futtatja, ez alapértelmezés szerint engedélyezve van.

browser.isolate

Típus: boolean
Alapértelmezett: true
CLI: --browser.isolate, --browser.isolate=false

Minden tesztet külön iframe-ben futtat.

browser.fileParallelism 1.3.0+

Típus: boolean
Alapértelmezett: ugyanaz, mint a fileParallelism
CLI: --browser.fileParallelism=false

Létrehozza az összes teszt iframe-et egyszerre, lehetővé téve a párhuzamos futtatást.

Ez megakadályozza az interaktív API-k (például kattintás vagy lebegés) használatát, mivel egyszerre több iframe van a képernyőn. Ha a tesztjei nem támaszkodnak ezekre az API-kra, sokkal gyorsabb lehet az összes teszt egyidejű futtatása.

TIP

Ha letiltotta az izolációt a browser.isolate=false beállítással, a tesztfájlok továbbra is egymás után futnak a tesztfuttató jellegéből adódóan.

browser.api

Típus: number | { port?, strictPort?, host? }
Alapértelmezett: 63315
CLI: --browser.api=63315, --browser.api.port=1234, --browser.api.host=example.com

Konfigurálja a Vite szerver opcióit, amely a kódot szolgálja ki a böngészőben. Ez nem befolyásolja a test.api opciót.

browser.provider

Típus: 'webdriverio' | 'playwright' | string
Alapértelmezett: 'webdriverio'
CLI: --browser.provider=playwright

A böngészőtesztek futtatásához használt szolgáltató elérési útja. A Vitest két beépített szolgáltatót kínál: webdriverio (alapértelmezett) és playwright. Az egyéni szolgáltatókat default exporttal kell exportálni, és a következő formátumúaknak kell lenniük:

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

Ez egy haladó API könyvtárszerzők számára. Ha csak teszteket szeretne futtatni egy böngészőben, használja a browser opciót.

browser.providerOptions 1.0.0+

Típus: BrowserProviderOptions

A provider.initialize hívásakor a szolgáltatónak átadott opciók.

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

TIP

A beépített szolgáltatók használatakor a jobb típusbiztonság érdekében hozzáadhatja az alábbi típusok egyikét (a használt szolgáltatóhoz) a tsconfig compilerOptions.types mezőjéhez:

json

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

browser.slowHijackESM 0.31.0+

Típus: boolean
Alapértelmezett: false

Amikor a teszteket Node.js-ben futtatja, a Vitest a saját modul feloldását használhatja a modulok egyszerű mockolásához a vi.mock szintaxissal. Azonban az ES modulok feloldásának böngészőben történő replikálása bonyolultabb, ezért a forrásfájlokat át kell alakítani, mielőtt a böngésző használni tudná őket.

Ennek az opciónak nincs hatása a Node.js-ben futó tesztekre.

Ha az ES modulok kémkedésére támaszkodik a vi.spyOn segítségével, engedélyezheti ezt a kísérleti funkciót a modul exportok kémkedésének engedélyezéséhez.

browser.indexScripts 1.6.0+

Típus: BrowserScript[]
Alapértelmezett: []

Egyéni szkriptek, amelyeket a teszt iframe-ek inicializálása előtt az index HTML-be kell injektálni. Ez a HTML dokumentum csak iframe-eket állít be, és nem importálja a kódot.

A szkript src és content értékét a Vite bővítmények dolgozzák fel. A szkriptet a következő formában kell megadni:

export interface BrowserScript {
  /**
   * Ha a "content" meg van adva és a típus "module", akkor ez lesz az azonosítója.
   *
   * Ha TypeScript-et használ, itt hozzáadhatja például a `.ts` kiterjesztést.
   * @default `injected-${index}.js`
   */
  id?: string;
  /**
   * A beinjektálandó JavaScript tartalom. Ezt a karakterláncot a Vite bővítmények dolgozzák fel, ha a típus "module".
   *
   * Az `id` segítségével tippet adhat a Vite-nek a fájlkiterjesztésről.
   */
  content?: string;
  /**
   * A szkript elérési útja. Ezt az értéket a Vite oldja fel, így lehet egy node modul vagy egy fájl elérési útja.
   */
  src?: string;
  /**
   * Ha a szkriptet aszinkron módon kell betölteni.
   */
  async?: boolean;
  /**
   * Szkript típusa.
   * @default 'module'
   */
  type?: string;
}

browser.testerScripts 1.6.0+

Típus: BrowserScript[]
Alapértelmezett: []

Egyéni szkriptek, amelyeket be kell injektálni a tesztelő HTML-be, mielőtt a tesztkörnyezet inicializálódik. Ez hasznos a Vitest böngésző implementációjához szükséges polyfill-ek beillesztéséhez. Szinte minden esetben a setupFiles használata ajánlott helyette.

A szkript src és content értékét a Vite bővítmények dolgozzák fel.

clearMocks

Típus: boolean
Alapértelmezett: false

Minden teszt előtt meghívja a .mockClear() metódust minden mock objektumon. Ez törli a mock előzményeket, de nem állítja vissza az implementációt az alapértelmezettre.

mockReset

Típus: boolean
Alapértelmezett: false

Minden teszt előtt meghívja a .mockReset() metódust minden mock objektumon. Ez törli a mock előzményeket, és visszaállítja az implementációját egy üres függvényre (undefined értéket ad vissza).

restoreMocks

Típus: boolean
Alapértelmezett: false

Minden teszt előtt meghívja a .mockRestore() metódust minden mock objektumon. Ez törli a mock előzményeket, és visszaállítja az implementációját az eredetire.

unstubEnvs 0.26.0+

Típus: boolean
Alapértelmezett: false

Meghívja a vi.unstubAllEnvs függvényt minden teszt előtt.

unstubGlobals 0.26.0+

Típus: boolean
Alapértelmezett: false

Meghívja a vi.unstubAllGlobals függvényt minden teszt előtt.

testTransformMode 0.34.0+

Típus: { web?, ssr? }

Meghatározza az átalakítási módszert a glob mintának megfelelő, teszteken belül importált összes modulhoz. Alapértelmezés szerint a környezetre támaszkodik. Például a JSDOM környezettel rendelkező tesztek az összes fájlt ssr: false jelzővel dolgozzák fel, a Node környezettel rendelkező tesztek pedig az összes modult ssr: true értékkel.

testTransformMode.ssr

Típus: string[]
Alapértelmezett: []

Az SSR átalakítási folyamatot használja a megadott teszteken belüli összes modulhoz.
A Vite bővítmények ssr: true jelzőt kapnak a fájlok feldolgozásakor.

testTransformMode.web

Típus: string[]
Alapértelmezett: []

Először egy normál átalakítási folyamatot végez (böngészőre irányulva), majd egy SSR átírást a kód Node-ban történő futtatásához.
A Vite bővítmények ssr: false jelzőt kapnak a fájlok feldolgozásakor.

snapshotFormat*

Típus: PrettyFormatOptions

Pillanatképek formázási beállításai. Ezek a beállítások átadásra kerülnek a pretty-format csomagnak.

TIP

Vegye figyelembe, hogy az objektum plugins mezője figyelmen kívül marad.

Ha a pillanatkép szerializálót a pretty-format bővítményeken keresztül szeretné bővíteni, használja az expect.addSnapshotSerializer API-t vagy a snapshotSerializers opciót.

snapshotSerializers* 1.3.0+

Típus: string[]
Alapértelmezett: []

A pillanatkép teszteléshez használt pillanatkép szerializáló modulok elérési útjainak listája. Hasznos egyéni pillanatkép szerializálók hozzáadásához. További információkért lásd az Egyéni szerializáló részt.

resolveSnapshotPath*

Típus: (testPath: string, snapExtension: string) => string
Alapértelmezett: a pillanatkép fájlokat a __snapshots__ könyvtárban tárolja

Felülírja az alapértelmezett pillanatkép elérési útvonalát. Például a pillanatképek tesztfájlok melletti tárolásához:

import { defineConfig } from 'vitest/config';

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

allowOnly

Típus: boolean
Alapértelmezett: !process.env.CI
CLI: --allowOnly, --allowOnly=false

Engedélyezi a kizárólagosan (.only) megjelölt teszteket és csomagokat.

dangerouslyIgnoreUnhandledErrors*

Típus: boolean
Alapértelmezett: false
CLI: --dangerouslyIgnoreUnhandledErrors --dangerouslyIgnoreUnhandledErrors=false

Figyelmen kívül hagy minden nem kezelt hibát, amely előfordul. FIGYELEM: Használata nem ajánlott, mert elrejtheti a tesztekben lévő valódi problémákat!

passWithNoTests*

Típus: boolean
Alapértelmezett: false
CLI: --passWithNoTests, --passWithNoTests=false

A Vitest nem jelez hibát, ha nem talál teszteket.

logHeapUsage

Típus: boolean
Alapértelmezett: false
CLI: --logHeapUsage, --logHeapUsage=false

Megjeleníti a heap használatát minden teszt után. Hasznos a memóriaszivárgások hibakereséséhez.

css

Típus: boolean | { include?, exclude?, modules? }

Beállítja, hogy a CSS-t fel kell-e dolgozni. Ha ki van kapcsolva, a CSS fájlok üres karakterláncokkal lesznek helyettesítve a későbbi feldolgozás megkerülése érdekében. A CSS modulok egy proxy objektumot adnak vissza, hogy ne befolyásolják a futásidőt.

css.include

Típus: RegExp | RegExp[]
Alapértelmezett: []

RegExp minta azoknak a fájloknak a kiválasztásához, amelyek tényleges CSS-t adnak vissza, és amelyeket a Vite folyamat dolgoz fel.

TIP

Az összes CSS fájl feldolgozásához használja a /.+/ mintát.

css.exclude

Típus: RegExp | RegExp[]
Alapértelmezett: []

RegExp minta az üres CSS fájlt visszaadó fájlokhoz.

css.modules

Típus: { classNameStrategy? }
Alapértelmezett: {}

css.modules.classNameStrategy

Típus: 'stable' | 'scoped' | 'non-scoped'
Alapértelmezett: 'stable'

Ha a CSS fájlok feldolgozása engedélyezett, beállítható, hogy a CSS modulokon belüli osztálynevek hatókörrel rendelkezzenek-e. Kiválaszthatja az egyik opciót:

stable: az osztálynevek _${name}_${hashedFilename} formátumban jönnek létre, ami azt jelenti, hogy a generált osztály változatlan marad, ha a CSS tartalma módosul, de megváltozik, ha a fájl neve módosul, vagy a fájl egy másik mappába kerül. Ez a beállítás hasznos, ha pillanatkép funkciót használ.
scoped: az osztálynevek a szokásos módon lesznek generálva, tiszteletben tartva a css.modules.generateScopeName metódust, ha van ilyen, és a CSS feldolgozás engedélyezve van. Alapértelmezés szerint a fájlnév _${name}_${hash} formában lesz generálva, ahol a hash tartalmazza a fájlnevet és a fájl tartalmát.
non-scoped: az osztálynevek nem lesznek hashelve.

WARNING

Alapértelmezés szerint a Vitest proxy objektumot exportál, megkerülve a CSS modulok feldolgozását. Ha az osztályok CSS tulajdonságaira támaszkodik, engedélyeznie kell a CSS feldolgozást az include opcióval.

maxConcurrency

Típus: number
Alapértelmezett: 5
CLI: --max-concurrency=10, --maxConcurrency=10

A test.concurrent jelöléssel ellátott tesztek maximális száma, amely egyidejűleg futhat.

A fenti korlátot meghaladó tesztek sorba állnak, és akkor futnak, amikor egy hely felszabadul.

cache*

Típus: false
CLI: --no-cache, --cache=false

Ezzel az opcióval kapcsolhatod ki a gyorsítótár funkciót. A Vitest jelenleg a teszteredmények gyorsítótárát használja arra, hogy először a hosszabb ideig futó és a sikertelen teszteket futtassa.

sequence

Típus: { sequencer?, shuffle?, seed?, hooks?, setupFiles? }

Beállítások a tesztek sorrendjének meghatározásához.

A sequence beállításokat a CLI-ben pontozott jelöléssel adhatod meg:

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

sequence.sequencer*

Típus: TestSequencerConstructor
Alapértelmezett: BaseSequencer

Egy egyedi osztály, amely meghatározza a darabolási és rendezési módszereket. Kiterjesztheted a BaseSequencer-t a vitest/node-ból, ha csak a sort és a shard metódusok egyikét kell felülbírálnod, de mindkettőnek léteznie kell.

A darabolás a rendezés előtt történik, és csak akkor, ha a --shard opció meg van adva.

sequence.shuffle

Típus: boolean | { files?, tests? }
Alapértelmezett: false
CLI: --sequence.shuffle, --sequence.shuffle=false

Ha azt szeretnéd, hogy a fájlok és a tesztek véletlenszerű sorrendben fussanak, engedélyezheted ezt az opciót, vagy a CLI argumentummal --sequence.shuffle.

A Vitest általában gyorsítótárat használ a tesztek rendezéséhez, így a hosszú ideig futó tesztek korábban kezdődnek - ezáltal a tesztek gyorsabban futnak. Ha a fájlok és a tesztek véletlenszerű sorrendben futnak, elveszíted ezt a teljesítményjavulást, de hasznos lehet nyomon követni azokat a teszteket, amelyek véletlenül függenek egy korábbi futástól.

sequence.shuffle.files 1.4.0+

Típus: boolean
Alapértelmezett: false
CLI: --sequence.shuffle.files, --sequence.shuffle.files=false

Megadja, hogy a fájlok sorrendje véletlenszerű legyen-e. Ne feledd, hogy a hosszú ideig futó tesztek nem indulnak el korábban, ha engedélyezed ezt az opciót.

sequence.shuffle.tests 1.4.0+

Típus: boolean
Alapértelmezett: false
CLI: --sequence.shuffle.tests, --sequence.shuffle.tests=false

Megadja, hogy a tesztek sorrendje véletlenszerű legyen-e.

sequence.concurrent 0.32.2+

Típus: boolean
Alapértelmezett: false
CLI: --sequence.concurrent, --sequence.concurrent=false

Ha azt szeretnéd, hogy a tesztek párhuzamosan fussanak, engedélyezheted ezt az opcióval, vagy a CLI argumentummal --sequence.concurrent.

sequence.seed*

Típus: number
Alapértelmezett: Date.now()
CLI: --sequence.seed=1000

Beállítja a véletlenszám-generátor magját, ha a tesztek véletlenszerű sorrendben futnak.

sequence.hooks

Típus: 'stack' | 'list' | 'parallel'
Alapértelmezett: 'parallel'
CLI: --sequence.hooks=<value>

Megváltoztatja a hook-ok végrehajtásának sorrendjét.

stack fordított sorrendben rendezi az "after" hook-okat, a "before" hook-ok a definíciójuk sorrendjében futnak
list az összes hook-ot a definíciójuk sorrendjében rendezi
parallel a hook-okat egyetlen csoportban párhuzamosan futtatja (a szülő suite-ek hook-jai továbbra is a jelenlegi suite hook-jai előtt futnak)

TIP

Ez az opció nincs hatással az onTestFinished függvényre. Mindig fordított sorrendben hívódik meg.

sequence.setupFiles 0.29.3+

Típus: 'list' | 'parallel'
Alapértelmezett: 'parallel'
CLI: --sequence.setupFiles=<value>

Megváltoztatja a setup fájlok végrehajtásának sorrendjét.

list a setup fájlokat a definíciójuk sorrendjében futtatja
parallel a setup fájlokat párhuzamosan futtatja

typecheck

Beállítások a típusellenőrzés tesztkörnyezet konfigurálásához.

typecheck.enabled 1.0.0+

Típus: boolean
Alapértelmezett: false
CLI: --typecheck, --typecheck.enabled

Engedélyezi a típusellenőrzést a szokásos tesztek mellett.

typecheck.only 1.0.0+

Típus: boolean
Alapértelmezett: false
CLI: --typecheck.only

Csak a típusellenőrző teszteket futtatja, ha a típusellenőrzés engedélyezve van. A CLI használatakor ez az opció automatikusan engedélyezi a típusellenőrzést.

typecheck.checker

Típus: 'tsc' | 'vue-tsc' | string
Alapértelmezett: tsc

Milyen eszközt használjunk a típusellenőrzéshez? A Vitest a típustól függően egy folyamatot indít bizonyos paraméterekkel a könnyebb elemzés érdekében. A checkernek ugyanazt a kimeneti formátumot kell produkálnia, mint a tsc.

A typechecker használatához telepíteni kell a következő csomagokat:

a tsc a typescript csomagot igényli
a vue-tsc a vue-tsc csomagot igényli

Megadhatsz egy egyéni bináris fájl elérési útját vagy parancsnevet is, amely ugyanazt a kimenetet generálja, mint a tsc --noEmit --pretty false.

typecheck.include

Típus: string[]
Alapértelmezett: ['**/*.{test,spec}-d.?(c|m)[jt]s?(x)']

Glob minta a tesztfájlként értelmezendő fájlokra.

typecheck.exclude

Típus: string[]
Alapértelmezett: ['**/node_modules/**', '**/dist/**', '**/cypress/**', '**/.{idea,git,cache,output,temp}/**']

Glob minta a nem tesztfájlként kezelendő fájlokhoz.

typecheck.allowJs

Típus: boolean
Alapértelmezett: false

Ellenőrzi azokat a JS fájlokat, amelyek @ts-check kommentet tartalmaznak. Ha engedélyezve van a tsconfig-ban, ez nem írja felül.

typecheck.ignoreSourceErrors

Típus: boolean
Alapértelmezett: false

Ne jelezzen hibát, ha a Vitest a tesztfájlokon kívül talált hibákat. Ez egyáltalán nem fogja megjeleníteni a nem teszt hibákat.

Alapértelmezés szerint, ha a Vitest forráskódban hibát talál, a teszt suite meghiúsul.

typecheck.tsconfig

Típus: string
Alapértelmezett: megpróbálja megkeresni a legközelebbi tsconfig.json fájlt

Egyedi tsconfig elérési útja, a projekt gyökeréhez viszonyítva.

slowTestThreshold*

Típus: number
Alapértelmezett: 300
CLI: --slow-test-threshold=<number>, --slowTestThreshold=<number>

Az a milliszekundumérték, amely felett egy teszt lassúnak minősül, és a rendszer így jelenti az eredményekben.

chaiConfig 0.30.0+

Típus: { includeStack?, showDiff?, truncateThreshold? }
Alapértelmezett: { includeStack: false, showDiff: true, truncateThreshold: 40 }

Megfelel a Chai konfigurációjának.

chaiConfig.includeStack

Típus: boolean
Alapértelmezett: false

Meghatározza, hogy a stack trace szerepeljen-e az Assertion hibaüzenetben. Az alapértelmezett false elnyomja a stack trace-t a hibaüzenetben.

chaiConfig.showDiff

Típus: boolean
Alapértelmezett: true

Meghatározza, hogy a showDiff flag szerepeljen-e a kiváltott AssertionErrors-ban. A false mindig false lesz; a true akkor lesz true, ha az állítás diff megjelenítését kérte.

chaiConfig.truncateThreshold

Típus: number
Alapértelmezett: 40

Beállítja a tényleges és várt értékek megjelenítési hosszának küszöbértékét az állítási hibákban. Ha ez a küszöbérték túllépésre kerül, például nagy adatstruktúrák esetén, az értéket valami hasonlóra cserélik: [ Array(3) ] vagy { Object (prop1, prop2) }. Állítsd 0-ra, ha teljesen ki szeretnéd kapcsolni a csonkítást.

Ez a konfigurációs opció befolyásolja az értékek csonkítását a test.each címekben és az állítási hibaüzenetben.

bail 0.31.0+

Típus: number
Alapértelmezett: 0
CLI: --bail=<value>

Leállítja a teszt végrehajtását, ha a megadott számú teszt meghiúsult.

Ez nem kívánatos a CI buildek esetében, ahol csak a 100%-ban sikeres buildek a cél, és a teszt végrehajtását a lehető leghamarabb le kell állítani, ha teszthibák fordulnak elő. A bail opcióval felgyorsíthatod a CI futásokat, mivel megakadályozza, hogy további teszteket futtasson, ha hibák lépnek fel.

retry 0.32.3+

Típus: number
Alapértelmezett: 0
CLI: --retry=<value>

A teszt adott számú alkalommal történő újrapróbálkozása, ha az meghiúsul.

onConsoleLog*

Típus: (log: string, type: 'stdout' | 'stderr') => boolean | void

Egyedi kezelő a tesztekben használt console.log számára. Ha false értéket adsz vissza, a Vitest nem írja ki a naplót a konzolra.

Hasznos lehet harmadik féltől származó könyvtárak naplóinak kiszűrésére is.

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* 1.0.0+

Típus: (error: Error, frame: ParsedStack) => boolean | void

Szűrőfüggvény alkalmazása a stack trace minden egyes frame-jére a hibák kezelésekor. Az első argumentum, az error, egy olyan objektum, amelynek ugyanazok a tulajdonságai, mint egy szabványos Error objektumnak, de nem egy tényleges példány.

Hasznos lehet harmadik féltől származó könyvtárak stack trace frame-jeinek kiszűrésére.

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

export default defineConfig({
  test: {
    onStackTrace(error: Error, { file }: ParsedStack): boolean | void {
      // Ha ReferenceError-ral találkoztunk, mutassuk meg a teljes stack-et.
      if (error.name === 'ReferenceError') return;

      // Dobd el az összes frame-et a harmadik féltől származó könyvtárakból.
      if (file.includes('node_modules')) return false;
    },
  },
});

diff 0.34.5+

Típus: string
CLI: --diff=<value>

Elérési út egy diff konfigurációs fájlhoz, amelyet a diff felület generálásához használnak. Hasznos, ha testre szeretnéd szabni a diff megjelenítését.

vitest.diff.tsvitest.config.js

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

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

import { defineConfig } from 'vitest/config';

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

diff.truncateThreshold

Típus: number
Alapértelmezett: 0

A megjelenítendő diff eredményének maximális hossza. Az ezen küszöbérték feletti diffek csonkolásra kerülnek. A csonkolás nem lép érvénybe az alapértelmezett 0 értékkel.

diff.truncateAnnotation

Típus: string
Alapértelmezett: '... Diff result is truncated'

Megjegyzés, amely a diff eredmény végén jelenik meg, ha az csonkolva van.

diff.truncateAnnotationColor

Típus: DiffOptionsColor = (arg: string) => string
Alapértelmezett: noColor = (string: string): string => string

A csonkolási megjegyzés színe; az alapértelmezett kimenet színtelen.

fakeTimers

Típus: FakeTimerInstallOpts

Beállítások, amelyeket a Vitest átad a @sinon/fake-timers számára a vi.useFakeTimers() használatakor.

fakeTimers.now

Típus: number | Date
Alapértelmezett: Date.now()

Hamis időzítőket telepít a megadott Unix epoch-kal.

fakeTimers.toFake

Típus: ('setTimeout' | 'clearTimeout' | 'setImmediate' | 'clearImmediate' | 'setInterval' | 'clearInterval' | 'Date' | 'nextTick' | 'hrtime' | 'requestAnimationFrame' | 'cancelAnimationFrame' | 'requestIdleCallback' | 'cancelIdleCallback' | 'performance' | 'queueMicrotask')[]
Alapértelmezett: ['setTimeout', 'clearTimeout', 'setImmediate', 'clearImmediate', 'setInterval', 'clearInterval', 'Date']

A hamisítandó globális metódusok és API-k neveit tartalmazó tömb.

A setTimeout() és a nextTick() hamisításához add meg ezt a tulajdonságot ['setTimeout', 'nextTick'] formában.

A nextTick hamisítása nem támogatott, ha a Vitest-et node:child_process-en belül futtatod a --pool=forks használatával. A NodeJS belsőleg a process.nextTick-et használja a node:child_process-ben, és lefagy, ha hamisítják. A nextTick hamisítása támogatott, ha a Vitest-et --pool=threads használatával futtatod.

fakeTimers.loopLimit

Típus: number
Alapértelmezett: 10_000

Az időzítők maximális száma, amely futtatásra kerül a vi.runAllTimers() hívásakor.

fakeTimers.shouldAdvanceTime

Típus: boolean
Alapértelmezett: false

Megmondja a @sinonjs/fake-timers-nek, hogy automatikusan növelje a hamisított időt a valós rendszeridő eltolódása alapján (például a hamisított idő 20 ms-mal növekszik a valós rendszeridő 20 ms-os változásakor).

fakeTimers.advanceTimeDelta

Típus: number
Alapértelmezett: 20

Csak akkor releváns, ha a shouldAdvanceTime: true értékkel használod. A szimulált időt advanceTimeDelta milliszekundummal növeli a valós rendszeridő minden advanceTimeDelta ms-os változásakor.

fakeTimers.shouldClearNativeTimers

Típus: boolean
Alapértelmezett: false

Megmondja a hamis időzítőknek, hogy töröljék a "natív" (azaz nem hamis) időzítőket a megfelelő kezelőikre való delegálásával. Ezek alapértelmezés szerint nincsenek törölve, ami potenciálisan váratlan viselkedéshez vezethet, ha az időzítők a hamis időzítők munkamenetének megkezdése előtt léteztek.

workspace* 1.1.0+

Típus: string
CLI: --workspace=./file.js
Alapértelmezett: vitest.{workspace,projects}.{js,ts,json} közel a konfigurációs fájlhoz vagy a gyökérhez

A workspace konfigurációs fájl elérési útja a root könyvtárhoz viszonyítva.

isolate 1.1.0+

Típus: boolean
Alapértelmezett: true
CLI: --no-isolate, --isolate=false

A tesztek futtatása elkülönített környezetben. Ez az opció nem befolyásolja a vmThreads és vmForks pool-okat.

Ennek az opciónak a letiltása javíthatja a teljesítményt, ha a kódod nem támaszkodik mellékhatásokra (ami általában igaz a node környezetű projektekre).

TIP

Az elkülönítést letilthatod bizonyos pool-ok esetében a poolOptions tulajdonság használatával.

includeTaskLocation 1.4.0+

Típus: boolean
Alapértelmezett: false

Tartalmazza-e a location tulajdonságot, amikor a Vitest API feladatokat kap a reporters között. Ha sok teszted van, ez egy kis teljesítményromlást okozhat.

A location tulajdonság column és line értékekkel rendelkezik, amelyek a test vagy a describe pozíciójának felelnek meg az eredeti fájlban.

TIP

Ennek az opciónak nincs hatása, ha nem használsz egyéni kódot, amely erre támaszkodik.

snapshotEnvironment 1.6.0+

Típus: string

Egy egyéni snapshot környezet implementációjának elérési útja. Ez akkor hasznos, ha a teszteket olyan környezetben futtatod, amely nem támogatja a Node.js API-kat. Ennek az opciónak nincs hatása a böngésző futtatóra.

Ennek az objektumnak a SnapshotEnvironment interfészt kell implementálnia, és a snapshot fájlok feloldására, olvasására és írására szolgál:

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

Kiterjesztheted az alapértelmezett VitestSnapshotEnvironment-et a vitest/snapshot belépési pontból, ha csak az API egy részét kell felülírnod.

WARNING

Ez egy alacsony szintű opció, amelyet csak speciális esetekben érdemes használni, amikor nincs hozzáférésed az alapértelmezett Node.js API-khoz.

Ha csak a snapshot funkciót kell konfigurálnod, használd a snapshotFormat vagy a resolveSnapshotPath opciókat.

Vitest konfigurálása ​

include ​

exclude ​

includeSource ​

server 0.34.0+ ​

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 0.34.0+ ​

deps.optimizer.{mode}.enabled ​

deps.web 0.34.2+ ​

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 1.6.0+ ​

benchmark.compare 1.6.0+ ​

alias ​

globals ​

environment ​

environmentOptions ​

environmentMatchGlobs ​

poolMatchGlobs 0.29.4+ ​

update* ​

watch* ​

root ​

reporters* ​

outputFile* ​

pool* 1.0.0+ ​

threads* ​

forks* ​

vmThreads* ​

vmForks* ​

poolOptions* 1.0.0+ ​

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 1.1.0+ ​

maxWorkers 1.1.0+ ​

minWorkers 1.1.0+ ​

testTimeout ​

hookTimeout ​

teardownTimeout* ​

silent* ​

Vitest konfigurálása

include

exclude

includeSource

server 0.34.0+

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 0.34.0+

deps.optimizer.{mode}.enabled

deps.web 0.34.2+

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 1.6.0+

benchmark.compare 1.6.0+

alias

globals

environment

environmentOptions

environmentMatchGlobs

poolMatchGlobs 0.29.4+

update*

watch*

root

reporters*

outputFile*

pool* 1.0.0+

threads*

forks*

vmThreads*

vmForks*

poolOptions* 1.0.0+

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 1.1.0+

maxWorkers 1.1.0+

minWorkers 1.1.0+

testTimeout

hookTimeout

teardownTimeout*

silent*