Vitest konfigurálása

Konfiguráció

A vitest beolvassa a projekt gyökerében található vite.config.ts fájlt, ha az létezik, hogy a bővítmények és beállítások megegyezzenek a Vite alkalmazásodban használtakkal. Ha a teszteléshez más beállításokat szeretnél, vagy a fő alkalmazásod nem kifejezetten a Vite-re támaszkodik, akkor a következő lehetőségek közül választhatsz:

Hozz létre egy vitest.config.ts fájlt, amely magasabb prioritással rendelkezik, és felülírja a vite.config.ts konfigurációját.
Használd a --config opciót a CLI-ben, pl. vitest --config ./path/to/vitest.config.ts.
Használd a process.env.VITEST környezeti változót vagy a mode tulajdonságot a defineConfig-ban (ha nincs felülírva, test/benchmark értékre lesz állítva), hogy feltételesen alkalmazz különböző konfigurációt a vite.config.ts-ben.

A vitest konfigurálásához add hozzá a test tulajdonságot a Vite konfigurációs fájlodhoz. Szükséged lesz egy hivatkozásra a Vitest típusaira egy hármas perjel direktívával a konfigurációs fájl tetején, ha a defineConfig-ot magából a vite-ből importálod.

Ha a defineConfig-ot a vite-ből importálod, akkor ezt kell követned:

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

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

Ha a defineConfig-ot a vitest/config-ból importálod, akkor ezt kell követned:

import { defineConfig } from 'vitest/config';

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

Szükség esetén lekérheted a Vitest alapértelmezett beállításait, hogy kibővíthesd őket:

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

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

Ha külön vitest.config.js fájlt használsz, szükség esetén kiterjesztheted a Vite beállításait egy másik konfigurációs fájl segítségével:

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

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

WARNING

A mergeConfig segédfüggvény a Vitest v0.30.0 óta érhető el. Ha alacsonyabb verziót használsz, közvetlenül a vite-ből importálhatod.

Ha a vite konfigurációd függvényként van definiálva, akkor a konfigurációt így állíthatod be:

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

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

Opciók

TIP

A következő opciók mellett bármilyen konfigurációs opciót használhatsz a Vite konfigurációs fájljá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.

TIP

Minden olyan 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)']

A tesztfuttatásba bevonandó fájlok, globális minták használatával.

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.*']

A tesztfuttatásból kizárandó fájlok, globális minták használatával.

includeSource

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

Forráskódban lévő tesztfájlokra vonatkozó globális minták.

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

server

Típus: { sourcemap?, deps?, ... }
Verzió: Vitest 0.34.0 óta

Vite-Node szerver beállítások.

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 kiírása a fájlrendszerbe. Ha egy karakterláncot adsz meg, akkor a megadott útvonalra menti.

server.debug.loadDumppedModules

Típus: boolean

A kiírt modul beolvasása a fájlrendszerből, ha az létezik. Hasznos a hibakereséshez a fájlrendszerből származó mentési eredmény 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 a csomagot a natív Node.js-nek adja át. 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 a node_modules-ban található csomagneveket ismerik fel, vagy a deps.moduleDirectories mappában vannak megadva. 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 mappá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álsz, a Vitest a fájl elérési útjára alkalmazza, nem a csomagnév alapján.

server.deps.inline

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

A Vite feldolgozni fogja az inline modulokat. Ez hasznos lehet olyan csomagok feldolgozásához, amelyek .js fájlokat szállítanak ESM formátumban (amit a Node nem tud kezelni).

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

server.deps.fallbackCJS

Típus: boolean
Alapértelmezett: false

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

Ez potenciálisan okozhat eltéréseket, 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?, registerNodeLoader?, ... }

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

deps.optimizer

Típus: { ssr?, web? }
Verzió: Vitest 0.34.0 óta
Lásd még: Dep Optimization Options (Függőség optimalizálási opciók)

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

Amikor a Vitest egy, az include fájlban felsorolt külső könyvtárral találkozik, akkor azt az esbuild segítségével egyetlen fájlba kötegelve importálja. 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ód mostantól a kötegelt csomagokban is érvényesül.
A tesztjeidben lévő kód közelebb fut ahhoz, ahogyan a böngészőben fut.

Ne feledd, hogy csak a deps.optimizer?.[mode].include opcióban szereplő csomagok kötegelve. Egyes bővítmények automatikusan feltöltik ezt, mint például a Svelte. A Vite dokumentációjában többet olvashatsz az elérhető opciókról (a Vitest nem támogatja a disable és a noDiscovery opciókat). Alapértelmezés szerint a Vitest az optimizer.web fájlt használja a jsdom és a happy-dom környezetekhez, az optimizer.ssr fájlt pedig a node és az edge környezetekhez, de ez a transformMode segítségével konfigurálható.

Ez az opció átveszi az optimizeDeps beállításaidat is (a web Vitest kiterjeszti az optimizeDeps-t, az ssr - ssr.optimizeDeps-t). Ha újradefiniálod az include/exclude opciót a deps.optimizer fájlban, az kiterjeszti az optimizeDeps-t a tesztek futtatásakor. A Vitest automatikusan eltávolítja az azonos opciókat az include listából, ha azok szerepelnek az exclude fájlban.

TIP

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

deps.optimizer.{mode}.enabled

Típus: boolean
Alapértelmezett: true, ha >= Vite 4.3.2, egyébként false

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

Típus: { transformAssets?, ... }
Verzió: Vitest 0.34.2 óta

Azok az opciók, amelyek a külső fájlokra vonatkoznak, amikor 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-e az eszközfájlokat (.png, .svg, .jpg stb.), és a Vite-hoz hasonlóan oldja-e fel azokat a böngészőben.

Ez a modul egy alapértelmezett exporttal fog rendelkezni, amely megegyezik az eszköz elérési útjával, ha nincs megadva lekérdezés.

WARNING

Jelenleg ez az opció csak az experimentalVmThreads pool-lal működik.

deps.web.transformCss

Típus: boolean
Alapértelmezett: true

A Vitest feldolgozza-e a CSS (.css, .scss, .sass stb.) fájlokat, és a Vite-hoz hasonlóan oldja-e fel azokat a böngészőben.

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

WARNING

Jelenleg ez az opció csak az experimentalVmThreads pool-lal működik.

deps.web.transformGlobPattern

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

Regexp minta a transzformálandó külső fájlok illesztéséhez.

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

WARNING

Jelenleg ez az opció csak az experimentalVmThreads pool-lal működik.

deps.registerNodeLoader*

Típus: boolean
Alapértelmezett: false

A kísérleti Node loader használata a külső fájlokban lévő importok feloldásához, a Vite feloldási algoritmusával.

Ha le van tiltva, az alias és a <plugin>.resolveId nem befolyásolja a külső csomagokban lévő importokat (alapértelmezés szerint node_modules).

deps.interopDefault

Típus: boolean
Alapértelmezett: true

A CJS modulok alapértelmezett exportjának értelmezése névvel ellátott 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álsz Node környezetben névvel ellátott exportok használatával, akkor ezt a hibát fogod látni:

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 fogod látni 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álsz ennek megkerülésére, és nem fog meghiúsulni, de ezt a viselkedést manuálisan letilthatod, ha a kódod nincs feldolgozva.

deps.moduleDirectories

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

Azon mappák listája, amelyeket modulmappaként kell kezelni. Ez a konfigurációs opció befolyásolja a vi.mock viselkedését: ha nincs megadva gyár, és annak az elérési útja, amit mockolsz, 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 a külső modulokat natív Node.js-sel importálja, 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, ha továbbra is a node_modules mappában szeretnél csomagokat keresni, akkor vedd fel 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. Erről bővebben a dokumentációban olvashatsz.

benchmark

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

A vitest bench futtatásakor használt beállítások.

benchmark.include

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

Benchmark tesztfájlokra vonatkozó globális minták.

benchmark.exclude

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

Benchmark tesztfájlokra vonatkozó kizáró globális minták.

benchmark.includeSource

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

Forráskódban lévő benchmark tesztfájlokra vonatkozó globális minták. Ez az opció hasonló a includeSource opcióhoz.

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

benchmark.reporters

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

Egyéni jelentés a kimenet formázásához. Tartalmazhat egy vagy több beépített jelentésnevet, riporterpéldányt és/vagy egyéni riporterek elérési útjait.

benchmark.outputFile

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

A benchmark eredmények fájlba írása, amennyiben a --reporter=json opció is megadásra került. Ha egy karakterlánc helyett egy objektumot adsz meg, akkor egyéni kimeneteket definiálhatsz, ha több riportert használsz.

Ha objektumot szeretnél megadni a CLI parancson keresztül, használd a következő szintaxist: --outputFile.json=./path --outputFile.junit=./other-path.

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áskor. Ezek egyesülnek a resolve.alias aliasokkal.

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 nagyobb explicitás érdekében. Ha inkább globálisan szeretnéd használni az API-kat, mint a Jest, akkor átadhatod a --globals opciót a CLI-nek, vagy hozzáadhatod a globals: true értéket a konfigurációban.

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

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

Ahhoz, hogy a TypeScript működjön a globális API-kkal, add 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álod az unplugin-auto-import fájlt a projektben, akkor közvetlenül is használhatod az API-k automatikus importálásához.

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

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

environment

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 fejlesztesz, böngészőszerű környezetben is futtathatod a teszteket a jsdom vagy a happy-dom segítségével. Edge függvények fejlesztése esetén használhatod az edge-runtime környezetet.

Egy @vitest-environment dokumentációs blokk vagy komment hozzáadásával a fájl tetején beállíthatsz egy másik környezetet, amelyet a fájl összes tesztjéhez 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 --threads=false flag-gel futtatod, a tesztek a következő sorrendben futnak: node, jsdom, happy-dom, edge-runtime, custom environments. Ez azt jelenti, hogy az azonos környezetű tesztek csoportosítva futnak, de továbbra is szekvenciálisan.

A 0.23.0-tól kezdve egyedi környezeteket is definiálhatsz. Ha nem beépített környezetet használsz, 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() {
    // Egyedi beállítás
    return {
      teardown() {
        // Meghívásra kerül, miután minden teszt lefutott ebben a környezetben
      },
    };
  },
};

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

environmentOptions

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

Ezek az opciók a jelenlegi environment setup metódusának kerülnek átadásra. Alapértelmezés szerint csak a JSDOM opcióit konfigurálhatod, ha ezt használod tesztkörnyezetként.

environmentMatchGlobs

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

Automatikusan hozzárendeli a környezetet a glob minták alapján. Az első egyezés lesz érvényes.

Például:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    environmentMatchGlobs: [
      // Az összes teszt a tests/dom-ban jsdom-ban fog futni
      ['tests/dom/**', 'jsdom'],
      // Az összes teszt a tests/-ben .edge.test.ts-el edge-runtime-ban fog futni
      ['**/*.edge.test.ts', 'edge-runtime'],
      // ...
    ],
  },
});

poolMatchGlobs

Típus: [string, 'threads' | 'child_process' | 'experimentalVmThreads'][]
Alapértelmezett: []
Verzió: Vitest 0.29.4 óta

Automatikusan hozzárendeli a pool-t, amelyben a tesztek a glob minták alapján futnak. Az első egyezés lesz érvényes.

Például:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolMatchGlobs: [
      // Az összes teszt a "worker-specific" könyvtárban egy worker-en belül fog futni, mintha engedélyezted volna a `--threads`-et számukra
      ['**/tests/worker-specific/**', 'threads'],
      // Futtass minden tesztet a "browser" könyvtárban egy tényleges böngészőben
      ['**/tests/browser/**', 'browser'],
      // Az összes többi teszt a "browser.enabled" és a "threads" opciók alapján fog futni, ha nem adtál meg más globokat
      // ...
    ],
  },
});

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

Egyedi riporterek a kimenethez. A riporterek lehetnek Reporter példányok vagy egy string a beépített riporterek kiválasztásához:

'default' - Összecsukja a suite-okat, ha sikeresek
'basic' - Az alapértelmezett riporterhez hasonló kimenetet ad a CI-ben
'verbose' - A teljes feladatfát láthatóvá teszi
'dot' - Minden feladatot egyetlen pontként jelenít meg
'junit' - JUnit XML riporter (a testsuites tag nevet a VITEST_JUNIT_SUITE_NAME környezeti változóval, a classname tag tulajdonságot pedig a VITEST_JUNIT_CLASSNAME változóval konfigurálhatod)
'json' - Egy egyszerű JSON összefoglalót ad
'html' - HTML jelentést ad ki a @vitest/ui alapján
'hanging-process' - Megjeleníti a függőben lévő folyamatok listáját, ha a Vitest nem tudja biztonságosan befejezni a folyamatot. Ez egy nehéz művelet lehet, csak akkor engedélyezd, ha a Vitest következetesen nem tudja befejezni a folyamatot
egyedi riporter elérési útja (pl. './path/to/reporter.ts', '@scope/reporter')

outputFile*

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

A teszteredményeket egy fájlba írja, ha a --reporter=json, --reporter=html vagy --reporter=junit opció is meg van adva. Ha egy string helyett egy objektumot adsz meg, egyedi kimeneteket definiálhatsz, ha több riportert használsz.

experimentalVmThreads

Típus: boolean
CLI: --experimentalVmThreads, --experimental-vm-threads
Verzió: Vitest 0.34.0 óta

A teszteket VM context (egy sandboxolt környezeten belül) használatával futtatja egy worker poolban.

Ez gyorsabb tesztfutást eredményezhet, de a VM modul instabil, ha ESM kódot futtat. A tesztek memóriaszivárgáshoz vezethetnek - ennek elkerülése érdekében fontold meg az experimentalVmWorkerMemoryLimit értékének manuális beállítását.

WARNING

A kód sandboxban történő futtatásának vannak előnyei (gyorsabb tesztek), de számos hátránya is van.

A natív modulokon belüli globális változók, mint például (fs, path stb.), eltérnek a tesztkörnyezetben jelenlévő globális változóktól. Ennek eredményeként az ezen natív modulok által kiváltott hibák egy másik Error konstruktorra hivatkoznak, mint a kódodban 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 kontextusod (tesztfájlod) van. A Node.js-ben nincs API a gyorsítótár törlésére.
A globális változók elérése tovább tart egy sandbox környezetben.

Fontold meg ezeket a problémákat, amikor ezt az opciót használod. A Vitest csapata nem tudja kijavítani a problémákat a mi oldalunkon.

experimentalVmWorkerMemoryLimit

Típus: string | number
CLI: --experimentalVmWorkerMemoryLimit, --experimental-vm-worker-memory-limit
Alapértelmezett: 1 / CPU magok száma
Verzió: Vitest 0.34.0 óta

Megadja a workerek memóriakorlátját, mielőtt újrahasznosítják őket. Ez az érték nagymértékben függ a környezetedtől, ezért javasolt manuálisan megadni, ahelyett, hogy az alapértelmezettet használnád.

Ez az opció csak azokat a worker-eket érinti, amelyek a teszteket VM context használatával futtatják.

TIP

A megvalósítás a Jest workerIdleMemoryLimit alapján történik.

A korlát többféleképpen megadható, és a Math.floor használatával egész értékké alakítjuk:

<= 1 - Az érték a rendszermemória százalékos arányának tekintendő. Tehát a 0,5 a worker memóriakorlátját a teljes rendszermemória felére állítja be
\> 1 - Fix bájtértéknek tekintendő. Az előző szabály miatt, ha 1 bájtos értéket szeretnél (nem tudom miért), használhatsz 1,1-et.
Mértékegységekkel
- 50% - Mint fent, a teljes rendszermemória százalékos aránya
- 100KB, 65MB stb. - Mértékegységekkel a fix memóriakorlát jelzésére.
  - K / KB - Kilobájt (x1000)
  - KiB - Kibibájt (x1024)
  - 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 worker-eken, mert helytelen rendszermemóriát jelentenek.

threads

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

Engedélyezi a többszálúságot a tinypool (a Piscina könnyűsúlyú forkja) használatával. A Vitest 0.29.0 előtt a Vitest továbbra is worker szálon belül futtatta a teszteket, még akkor is, ha ez az opció le volt tiltva. A 0.29.0 óta, ha ez az opció le van tiltva, a Vitest a child_process segítségével hoz létre egy folyamatot a tesztek futtatásához, ami azt jelenti, hogy használhatod a process.chdir-t és más API-kat, amelyek nem voltak elérhetők a worker-eken belül. Ha vissza szeretnél térni az előző viselkedéshez, használd a --single-thread opciót helyette.

Ennek az opciónak a letiltása az összes tesztet külön gyermekfolyamatokban futtatja.

singleThread

Típus: boolean
Alapértelmezett: false
Verzió: Vitest 0.29.0 óta

Az összes tesztet ugyanazzal a környezettel futtatja egyetlen worker szálon belül. Ez letiltja a beépített modul izolációt (a forráskódod vagy az inlined kód továbbra is újraértékelésre kerül minden teszthez), de javíthatja a teszt teljesítményét. A Vitest 0.29.0 előtt ez egyenértékű volt a --no-threads használatával.

WARNING

Annak ellenére, hogy 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 worker-eket, hanem az izoláció megvalósítására is. Ennek az opciónak a letiltásával a tesztek szekvenciálisan futnak, de ugyanabban a globális kontextusban, ezért neked kell biztosítanod az izolációt.

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

maxThreads*

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

A szálak maximális számának megadása. Használhatod a VITEST_MAX_THREADS környezeti változót is.

minThreads*

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

A szálak minimális számának megadása. Használhatod a VITEST_MIN_THREADS környezeti változót is.

useAtomics*

Típus: boolean
Alapértelmezett: false
Verzió: Vitest 0.28.3 óta

Atomics használata a szálak szinkronizálásához.

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

testTimeout

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

Egy teszt alapértelmezett időtúllépésének megadása milliszekundumban

hookTimeout

Típus: number
Alapértelmezett: 10000

Egy hook alapértelmezett időtúllépésének megadása milliszekundumban

teardownTimeout*

Típus: number
Alapértelmezett: 10000

Alapértelmezett időtúllépés a leállásra való várakozáshoz, amikor a Vitest leáll, milliszekundumban

silent*

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

Tesztkimenetek elnémítása a konzolon

setupFiles

Típus: string | string[]

Az előkészítő fájlok elérési útja. Ezek minden tesztfájl előtt lefutnak.

INFO

Az előkészítő fájlok módosítása minden teszt újrafuttatását eredményezi.

Használhatod a process.env.VITEST_POOL_ID-t (egész számot tartalmazó string) a szálak megkülönböztetésére (mindig '1' lesz, ha threads: false értékkel fut).

TIP

Fontos, hogy ha a --threads=false opcióval futtatod, ez az előkészítő fájl többször is lefut ugyanabban a globális hatókörben. Ez azt jelenti, hogy minden teszt előtt ugyanazt a globális objektumot éred el, ezért győződj meg arról, hogy nem végzel ugyanazt a műveletet többször, mint amennyire szükséges.

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

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

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

// A hook függvények minden tesztcsoport előtt alaphelyzetbe kerülnek
afterEach(() => {
  cleanup();
});

globalThis.resetBeforeEachTest = true;

globalSetup

Típus: string | string[]

A globális előkészítő fájlok elérési útja, a projekt gyökeréhez viszonyítva

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

INFO

Több globális előkészítő fájl is lehetséges. A setup és a teardown szekvenciálisan futnak, a teardown a setup-okkal ellentétes sorrendben.

WARNING

Ne feledd, hogy a globális előkészítés egy másik globális hatókörben fut, így a tesztek nem férnek hozzá az itt definiált változókhoz.

watchExclude*

Típus: string[]
Alapértelmezett: ['**/node_modules/**', '**/dist/**']

Glob minta a fájlok elérési útjaira, amelyeket figyelmen kívül kell hagyni a figyelő újrafuttatásának kiváltásakor.

forceRerunTriggers*

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

Glob minta a fájlok elérési útjaira, amelyek az egész suite újrafuttatását eredményezik. A --changed argumentummal párosítva az egész teszt suite-ot futtatja, ha a trigger megtalálható a git diff-ben.

Hasznos, ha CLI parancsok hívását teszteled, 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 meg arról, hogy a fájljaidat nem zárja ki a watchExclude.

isolate

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

Minden tesztfájlhoz különálló tesztkörnyezetet hoz létre. Nem működik, ha a --threads opció le van tiltva.

Ennek az opciónak nincs hatása az experimentalVmThreads opcióra.

coverage*

Használhatja a v8, istanbul vagy egyéni lefedettség megoldást a lefedettség méréséhez.

A lefedettség opciókat a CLI-ben pont jelöléssel adhatja meg:

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

WARNING

Ha pont jelöléssel használja a lefedettség opciókat, ne felejtse el megadni a --coverage.enabled opciót. Ne adjon meg külön --coverage opciót ebben az esetben.

coverage.provider

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

A provider segítségével kiválaszthatja a lefedettség méréséhez használt eszközt.

coverage.enabled

Típus: boolean
Alapértelmezett: false
Elérhető szolgáltatókhoz: 'v8' | 'istanbul'
CLI: --coverage.enabled, --coverage.enabled=false

Engedélyezi a lefedettség mérést. Felülírható a --coverage CLI opcióval.

coverage.include

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

Glob mintákként megadott fájlok listája, amelyek bekerülnek a lefedettségbe.

coverage.extension

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

A lefedettség méréséhez figyelembe vett fájlkiterjesztések listája.

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}.?(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ő szolgáltatókhoz: 'v8' | 'istanbul'
CLI: --coverage.exclude=<path>, --coverage.exclude=<path1> --coverage.exclude=<path2>

A lefedettségből kizárt fájlok listája glob minták formájában.

coverage.all

Típus: boolean
Alapértelmezett: false
Elérhető szolgáltatókhoz: 'v8' | 'istanbul'
CLI: --coverage.all, --coverage.all=false

Meghatározza, hogy a jelentés tartalmazza-e az összes fájlt, beleértve a nem tesztelteket is.

coverage.clean

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

A tesztek futtatása előtt törli a korábbi lefedettségi eredményeket.

coverage.cleanOnRerun

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

Törli a lefedettségmérési jelentést az újrafuttatáskor (watch módban).

coverage.reportsDirectory

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

A lefedettségmérési jelentések mentési könyvtára.

coverage.reporter

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

A használandó lefedettségi riporterek listája. A riporterek részletes listáját lásd az istanbul dokumentációjában. A riporter-specifikus opciókkal kapcsolatos részletekért lásd a @types/istanbul-reporter oldalt.

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

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

Egy vagy több riporter riporter opciókkal:

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

A Vitest 0.31.0 óta ellenőrizheti a lefedettségi jelentést a Vitest UI-ban: további részletekért nézze meg a Vitest UI lefedettség oldalt.

coverage.reportOnFailure

Típus: boolean
Alapértelmezett: false (a Vitest 0.34.0 óta)
Elérhető szolgáltatókhoz: 'v8' | 'istanbul'
CLI: --coverage.reportOnFailure, --coverage.reportOnFailure=false
Verzió: A Vitest 0.31.2 óta

Lefedettségmérési jelentést generál akkor is, ha a tesztek sikertelenek.

coverage.allowExternal

Típus: boolean
Alapértelmezett: false
Elérhető szolgáltatókhoz: 'v8' | 'istanbul'
CLI: --coverage.allowExternal, --coverage.allowExternal=false

Lehetővé teszi a lefedettségmérést a projekt root könyvtárán kívüli fájlokra is.

coverage.skipFull

Típus: boolean
Alapértelmezett: false
Elérhető szolgáltatókhoz: 'v8' | 'istanbul'
CLI: --coverage.skipFull, --coverage.skipFull=false

Nem jeleníti meg azokat a fájlokat, amelyek 100%-os utasítás-, ág- és függvénylefedettséget mutatnak.

coverage.perFile

Típus: boolean
Alapértelmezett: false
Elérhető szolgáltatókhoz: 'v8' | 'istanbul'
CLI: --coverage.perFile, --coverage.perFile=false

Ellenőrzi a küszöbértékeket fájlonként. A tényleges küszöbértékekért lásd a lines, functions, branches és statements beállításokat.

coverage.thresholdAutoUpdate

Típus: boolean
Alapértelmezett: false
Elérhető szolgáltatókhoz: 'v8' | 'istanbul'
CLI: --coverage.thresholdAutoUpdate=<boolean>

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

coverage.lines

Típus: number
Elérhető szolgáltatókhoz: 'v8' | 'istanbul'
CLI: --coverage.lines=<number>

A sorok lefedettségének küszöbértéke. További információkért lásd az istanbul dokumentációját.

coverage.functions

Típus: number
Elérhető szolgáltatókhoz: 'v8' | 'istanbul'
CLI: --coverage.functions=<number>

A függvények lefedettségének küszöbértéke. További információkért lásd az istanbul dokumentációját.

coverage.branches

Típus: number
Elérhető szolgáltatókhoz: 'v8' | 'istanbul'
CLI: --coverage.branches=<number>

Az ágak lefedettségének küszöbértéke. További információkért lásd az istanbul dokumentációját.

coverage.statements

Típus: number
Elérhető szolgáltatókhoz: 'v8' | 'istanbul'
CLI: --coverage.statements=<number>

Az utasítások lefedettségének küszöbértéke. További információkért lásd az istanbul dokumentációját.

coverage.100

Típus: boolean
Alapértelmezett: false
Elérhető szolgáltatókhoz: 'v8' | 'istanbul'
CLI: --coverage.100, --coverage.100=false

Rövidítés a --coverage.lines 100 --coverage.functions 100 --coverage.branches 100 --coverage.statements 100 beállításhoz.

coverage.ignoreClassMethods

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

Itt adhatja meg a lefedettségmérésből kihagyandó osztálymetódusok neveit egy tömbben. 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ő szolgáltatókhoz: 'v8' | 'istanbul'

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

coverage.customProviderModule

Típus: string
Elérhető szolgáltatókhoz: 'custom'
CLI: --coverage.customProviderModule=<path or module name>

Megadja az egyéni lefedettség szolgáltató modul modulnevét vagy elérési útját. További információkért lásd: Útmutató - Egyéni lefedettség szolgáltató.

testNamePattern*

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

A mintának megfelelő teljes nevű teszteket futtatja. Ha hozzáadja az OnlyRunThis tulajdonságot ehhez a tulajdonsághoz, a teszt nevében az OnlyRunThis szót nem tartalmazó tesztek kihagyásra kerülnek.

import { expect, test } from 'vitest';

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

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

open*

Típus: boolean
Alapértelmezett: false
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

Figyeli a megadott portot és API-t biztosít. Ha igaz értékre van állítva, az alapértelmezett port az 51204.

browser

Típus: { enabled?, name?, provider?, headless?, api?, slowHijackESM? }
Alapértelmezett: { enabled: false, headless: process.env.CI, api: 63315 }
Verzió: A Vitest 0.29.4 óta
CLI: --browser, --browser=<name>, --browser.name=chrome --browser.headless

Futtassa a Vitest teszteket egy böngészőben. Alapértelmezés szerint a WebdriverIO alkalmazást használjuk a tesztek futtatásához, de a browser.provider opcióval konfigurálható.

MEGJEGYZÉS

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

WARNING

Ez egy kísérleti jellegű funkció. A nem kompatibilis változások nem feltétlenül követik a szemantikus verziózás (semver) szabályait, ezért használata esetén javasolt a Vitest verziójának rögzítése.

browser.enabled

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

Alapértelmezés szerint az összes tesztet böngészőben futtatja. Felülbírálható a poolMatchGlobs opcióval.

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
custom (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 módban futtatja. Ha a Vitest CI környezetben fut, ez az opció alapértelmezetten engedélyezve van.

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 a böngészőben szolgálja ki. Nincs hatással a test.api opcióra.

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 szolgáltatót biztosít: a webdriverio (alapértelmezett) és a playwright. Az egyéni szolgáltatókat default exporttal kell exportálni, és a következő formátumúnak kell lenniük:

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

WARNING

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

browser.slowHijackESM

Típus: boolean
Alapértelmezett: true
Verzió: Vitest 0.31.0-tól

Node.js-ben futó tesztek esetén a Vitest saját modul feloldási mechanizmusát használhatja a modulok egyszerű mockolására a vi.mock szintaxissal. Az ES modulok feloldásának böngészőben történő replikálása azonban nem egyszerű, 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.

Ez az opció alapértelmezés szerint engedélyezve van, ha böngészőben fut. Ha nem használja a vi.spyOn-t az ES modulok megfigyelésére és a vi.mock-ot sem, letilthatja ezt a funkciót a teljesítmény kis mértékű növelése érdekében.

clearMocks

Típus: boolean
Alapértelmezett: false

Minden teszt előtt meghívja a .mockClear() függvényt az összes kémre. Ez törli a mockolt hívások előzményeit, de nem állítja vissza az implementációt az alapértelmezett értékre.

mockReset

Típus: boolean
Alapértelmezett: false

Minden teszt előtt meghívja a .mockReset() függvényt az összes kémre. Ez törli a mockolt hívások előzményeit és visszaállítja az implementációt egy üres függvényre, amely undefined értéket ad vissza.

restoreMocks

Típus: boolean
Alapértelmezett: false

Minden teszt előtt meghívja a .mockRestore() függvényt az összes kémre. Ez törli a mockolt hívások előzményeit és visszaállítja az implementációt az eredeti állapotába.

unstubEnvs

Típus: boolean
Alapértelmezett: false
Verzió: Vitest 0.26.0 óta

Meghívja a vi.unstubAllEnvs metódust minden teszt előtt.

unstubGlobals

Típus: boolean
Alapértelmezett: false
Verzió: Vitest 0.26.0 óta

Meghívja a vi.unstubAllGlobals metódust minden teszt előtt.

testTransformMode

Típus: { web?, ssr? }
Verzió: Vitest 0.34.0 óta

Meghatározza az átalakítási módot a glob mintának megfelelő összes modulra, amelyet egy teszten belül importálnak. 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 jelzővel.

testTransformMode.ssr

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

A megadott teszteken belüli összes modulhoz szerver oldali renderelés (SSR) átalakítási folyamatot használ.
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 (böngészőre irányuló) átalakítási folyamatot végez, majd egy SSR újraírást végez 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ép tesztelés formázási beállításai. Ezek a beállítások a pretty-format csomagnak kerülnek átadásra.

resolveSnapshotPath*

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

Felülírja az alapértelmezett pillanatkép útvonalat. Például a pillanatképek tárolásához a tesztfájlok mellett:

import { defineConfig } from 'vitest/config';

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

allowOnly

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

Engedélyezi a csakként megjelölt teszteket és tesztcsomagokat.

dangerouslyIgnoreUnhandledErrors*

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

Figyelmen kívül hagy minden nem kezelt hibát, amely előfordul.

passWithNoTests*

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

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

logHeapUsage

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

Megmutatja a heap használatot minden teszt után. Hasznos a memóriaszivárgások hibakereséséhez.

css

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

Konfigurálja, hogy a CSS-t fel kell-e dolgozni. Ha ki van zárva, a CSS fájlok üres karakterláncokkal lesznek helyettesítve a későbbi feldolgozás elkerülése érdekében. A CSS modulok egy proxyt adnak vissza, hogy ne befolyásolják a futási időt.

css.include

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

RegExp minta azokhoz a fájlokhoz, amelyeknek tényleges CSS-t kell visszaadniuk, és amelyeket a Vite folyamat fog feldolgozni.

TIP

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

css.exclude

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

RegExp minta azokhoz a fájlokhoz, amelyek üres CSS fájlt adnak vissza.

css.modules

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

css.modules.classNameStrategy

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

Ha úgy dönt, hogy feldolgozza a CSS fájlokat, konfigurálhatja, hogy a CSS modulokon belüli osztálynevek rendelkezzenek-e hatókörrel. Kiválaszthatja az egyik lehetőséget:

stable: az osztálynevek _${name}_${hashedFilename} formában lesznek generálva, ami azt jelenti, hogy a generált osztály ugyanaz marad, ha a CSS tartalma megváltozik, 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 akkor hasznos, ha pillanatkép-funkciót használ.
scoped: az osztálynevek a szokásos módon lesznek generálva, figyelembe véve 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 egy proxyt 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ó használatával.

maxConcurrency

Típus: number
Alapértelmezett: 5

Az egyidejűleg futtatható tesztek száma, amelyek test.concurrent -ként vannak megjelölve.

A fenti korlátot meghaladó tesztek sorba kerülnek, hogy fusson, amikor elérhető hely jelenik meg.

cache*

Típus: false | { dir? }

A Vitest gyorsítótár-kezelési szabályzatának konfigurálására szolgáló beállítások. Jelenleg a Vitest a teszteredmények gyorsítótárát tárolja, hogy a hosszabb és sikertelen teszteket futtassa először.

cache.dir

Típus: string
Alapértelmezett: node_modules/.vitest

A gyorsítótár könyvtárának elérési útja.

sequence

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

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

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

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

sequence.sequencer*

Típus: TestSequencerConstructor
Alapértelmezett: BaseSequencer

Egy egyéni osztály, amely meghatározza a szegmentáláshoz és rendezéshez használt metódusokat. Kiterjesztheti a BaseSequencer -t a vitest/node -ból, ha csak a sort és a shard metódusok egyikét kell újradefiniálnia, de mindkettőnek léteznie kell.

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

sequence.shuffle

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

Ha azt szeretné, hogy a tesztek véletlenszerű sorrendben fussanak, engedélyezheti ezt az opcióval vagy a --sequence.shuffle CLI argumentummal.

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 tesztek véletlenszerű sorrendben futnak, elveszíti ezt a teljesítményjavulást, de hasznos lehet nyomon követni azokat a teszteket, amelyek véletlenül egy korábbi futtatástól függenek.

sequence.concurrent

Típus: boolean
Alapértelmezett: false
CLI: --sequence.concurrent, --sequence.concurrent=false
Verzió: Vitest 0.32.2 óta

Ha azt szeretné, hogy a tesztek párhuzamosan fussanak, engedélyezheti 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életlenszerűsítési magot, 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ási sorrendjét.

stack megfordítja az "after" hook-ok sorrendjét, 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ő tesztcsomagok hook-jai továbbra is a jelenlegi tesztcsomag hook-jai előtt futnak)

sequence.setupFiles

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

Megváltoztatja a beállító fájlok végrehajtásának sorrendjét.

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

typecheck

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

typecheck.checker

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

Milyen eszközöket használjon a típusellenőrzéshez. A Vitest egy folyamatot indít bizonyos paraméterekkel a könnyebb elemzés érdekében, a típustól függően. A Checker-nek ugyanazt a kimeneti formátumot kell megvalósítania, mint a tsc.

Telepítenie kell egy csomagot a típusellenőrző használatához:

a tsc -hez a typescript csomag szükséges
a vue-tsc -hez a vue-tsc csomag szükséges

Átadhat egy elérési utat egy egyéni bináris fájlhoz vagy parancsnévhez 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)']

Globminta azokhoz a fájlokhoz, amelyeket tesztfájlokként kell kezelni.

typecheck.exclude

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

Globminta azokhoz a fájlokhoz, amelyeket nem szabad tesztfájlokként kezelni.

typecheck.allowJs

Típus: boolean
Alapértelmezett: false

Ellenőrzi a @ts-check megjegyzéssel rendelkező JS fájlokat. Ha engedélyezve van a tsconfig fájlban, 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üli forráskódban talált hibákat. Ez egyáltalán nem mutatja meg a nem teszt hibákat.

Alapértelmezés szerint, ha a Vitest forráshibát talál, a tesztcsomag sikertelen lesz.

typecheck.tsconfig

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

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

slowTestThreshold*

Típus: number
Alapértelmezett: 300

Az a milliszekundumok száma, amely után egy teszt lassúnak minősül, és a rendszer így jelenti az eredményekben.

chaiConfig

Típus: { includeStack?, showDiff?, truncateThreshold? }
Alapértelmezett: { includeStack: false, showDiff: true, truncateThreshold: 40 }
Verzió: Vitest 0.30.0 óta

Megfelel a Chai konfigurációnak.

chaiConfig.includeStack

Típus: boolean
Alapértelmezett: false

Befolyásolja, hogy a veremkövetés szerepel-e az Assertion hibaüzenetben. Az alapértelmezett false elnyomja a veremkövetést a hibaüzenetben.

chaiConfig.showDiff

Típus: boolean
Alapértelmezett: true

Befolyásolja, hogy a showDiff jelző szerepeljen-e a kidobott AssertionErrors-ban. A false mindig false lesz; a true akkor lesz igaz, ha az állítás különbséget kért.

chaiConfig.truncateThreshold

Típus: number
Alapértelmezett: 40

Beállítja a tényleges és a várt értékek hosszúsági küszöbértékét az assertion 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éli: [ Array(3) ] vagy { Object (prop1, prop2) }. Állítsa 0 -ra, ha teljesen le szeretné tiltani 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üzenetekben.

bail

Típus: number
Alapértelmezett: 0
CLI: --bail=<value>
Verzió: Vitest 0.31.0 óta

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

Alapértelmezés szerint a Vitest az összes tesztesetet futtatja, még akkor is, ha néhányuk sikertelen. Ez nem kívánatos a CI build-ekhez, 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íthatja a CI futásokat azáltal, hogy megakadályozza, hogy több tesztet futtasson, amikor hibák történtek.

retry

Típus: number
Alapértelmezett: 0
CLI: --retry=<value>
Verzió: Vitest 0.32.3 óta

Újrapróbálja a tesztet a megadott számú alkalommal, ha sikertelen.

onConsoleLog

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

Egyéni kezelő a tesztek során használt console.log-hoz. Ha false értéket ad vissza, a Vitest nem fogja kiírni a naplót a konzolra.

Hasznos lehet külső könyvtárak naplóinak kiszűrésére.

import { defineConfig } from 'vitest/config';

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

diff

Típus: string
CLI: --diff=<value>
Verzió: Vitest 0.34.5 óta

Elérési út egy diff konfigurációhoz, amelyet a diff felület generálásához használnak. Hasznos, ha testre szeretné 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',
  },
});

Vitest konfigurálása ​

Konfiguráció ​

Opciók ​

include ​

exclude ​

includeSource ​

server ​

server.sourcemap ​

server.debug ​

server.debug.dumpModules ​

server.debug.loadDumppedModules ​

server.deps ​

server.deps.external ​

server.deps.inline ​

server.deps.fallbackCJS ​

server.deps.cacheDir ​

deps ​

deps.optimizer ​

deps.optimizer.{mode}.enabled ​

deps.web ​

deps.web.transformAssets ​

deps.web.transformCss ​

deps.web.transformGlobPattern ​

deps.registerNodeLoader* ​

deps.interopDefault ​

deps.moduleDirectories ​

runner ​

benchmark ​

benchmark.include ​

benchmark.exclude ​

benchmark.includeSource ​

benchmark.reporters ​

benchmark.outputFile ​

alias ​

globals ​

environment ​

environmentOptions ​

environmentMatchGlobs ​

poolMatchGlobs ​

update* ​

watch* ​

root ​

reporters* ​

outputFile* ​

experimentalVmThreads ​

experimentalVmWorkerMemoryLimit ​

threads ​

singleThread ​

maxThreads* ​

minThreads* ​

useAtomics* ​

testTimeout ​

hookTimeout ​

teardownTimeout* ​

silent* ​

setupFiles ​

globalSetup ​

watchExclude* ​

forceRerunTriggers* ​

isolate ​

coverage* ​

coverage.provider ​

coverage.enabled ​

coverage.include ​

coverage.extension ​

coverage.exclude ​

coverage.all ​

coverage.clean ​

coverage.cleanOnRerun ​

coverage.reportsDirectory ​

coverage.reporter ​

coverage.reportOnFailure ​

coverage.allowExternal ​

coverage.skipFull ​

coverage.perFile ​

coverage.thresholdAutoUpdate ​

coverage.lines ​

coverage.functions ​

coverage.branches ​

coverage.statements ​

Vitest konfigurálása

Konfiguráció

Opciók

include

exclude

includeSource

server

server.sourcemap

server.debug

server.debug.dumpModules

server.debug.loadDumppedModules

server.deps

server.deps.external

server.deps.inline

server.deps.fallbackCJS

server.deps.cacheDir

deps

deps.optimizer

deps.optimizer.{mode}.enabled

deps.web

deps.web.transformAssets

deps.web.transformCss

deps.web.transformGlobPattern

deps.registerNodeLoader*

deps.interopDefault

deps.moduleDirectories

runner

benchmark

benchmark.include

benchmark.exclude

benchmark.includeSource

benchmark.reporters

benchmark.outputFile

alias

globals

environment

environmentOptions

environmentMatchGlobs

poolMatchGlobs

update*

watch*

root

reporters*

outputFile*

experimentalVmThreads

experimentalVmWorkerMemoryLimit

threads

singleThread

maxThreads*

minThreads*

useAtomics*

testTimeout

hookTimeout

teardownTimeout*

silent*

setupFiles

globalSetup

watchExclude*

forceRerunTriggers*

isolate

coverage*

coverage.provider

coverage.enabled

coverage.include

coverage.extension

coverage.exclude

coverage.all

coverage.clean

coverage.cleanOnRerun

coverage.reportsDirectory

coverage.reporter

coverage.reportOnFailure

coverage.allowExternal

coverage.skipFull

coverage.perFile

coverage.thresholdAutoUpdate

coverage.lines

coverage.functions

coverage.branches

coverage.statements