Vitest konfigurálása

Ha Vite-ot használsz, és van egy vite.config fájlod, a Vitest beolvassa azt, hogy illeszkedjen a beépülő modulokhoz és a beállításhoz, mint a Vite alkalmazásod. Ha eltérő konfigurációt szeretnél a teszteléshez, vagy a fő alkalmazásod nem kifejezetten a Vite-ra támaszkodik, akkor a következőket teheted:

Hozz létre egy vitest.config.ts fájlt, amelynek magasabb prioritása lesz, és felülírja a vite.config.ts konfigurációját (a Vitest támogatja az összes hagyományos JS és TS kiterjesztést, de a json fájlokat nem) – ez azt jelenti, hogy a vite.config fájlban lévő összes opció figyelmen kívül lesz hagyva.
Add át a --config opciót a CLI-nek, pl. vitest --config ./path/to/vitest.config.ts
Használd a process.env.VITEST vagy a mode tulajdonságot a defineConfig fájlban (ez test/benchmark értékre lesz állítva, ha nincs felülírva a --mode opcióval), hogy feltételesen alkalmazz különböző konfigurációt a vite.config.ts fájlban.

A vitest konfigurálásához add hozzá a test tulajdonságot a Vite konfigurációdhoz. Szükséged lesz arra is, hogy hivatkozz a Vitest típusokra egy három perjel paranccsal a konfigurációs fájl tetején, ha a defineConfig fájlt magából a vite-ból importálod.

Konfigurációs példák megnyitása

A defineConfig használatával a vite-ból a következőket kell követned:

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

export default defineConfig({
  test: {
    // ... Itt add meg az opciókat.
  },
});

A <reference types="vitest" /> a Vitest 4-ben már nem fog működni, de már most elkezdheted a migrálást a vitest/config felé:

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

export default defineConfig({
  test: {
    // ... Itt add meg az opciókat.
  },
});

A defineConfig használatával a vitest/config fájlból a következőket kell követned:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    // ... Itt add meg az opciókat.
  },
});

A Vitest alapértelmezett opcióit lekérheted, hogy szükség esetén kibővítsd ő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 opcióit egy másik konfigurációs fájlból is:

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

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

Ha a Vite konfigurációd függvényként van definiálva, a konfigurációt így definiálhatod:

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

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

WARNING

Az ezen az oldalon felsorolt összes opció a konfigurációban egy test tulajdonságon belül található:

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

Mivel a Vitest Vite konfigurációt használ, bármely konfigurációs opciót használhatsz a Vite dokumentációjá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 – ezeket az opciókat a legfelső szinten kell definiálni, nem a test tulajdonságon belül.

Azok a konfigurációs opciók, amelyek nem támogatottak egy projekt konfigurációjában, * jelzéssel vannak ellátva. Ez azt jelenti, hogy csak a gyökér Vitest konfigurációban állíthatók be.

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ájljaidra.

MEGJEGYZÉS

A lefedettség használatakor a Vitest automatikusan hozzáadja a tesztfájlok include mintáit a lefedettség alapértelmezett exclude mintáihoz. Lásd: coverage.exclude.

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

Glob minták listája, amelyeket ki kell zárni a tesztfájljaidból.

WARNING

Ez az opció nem befolyásolja a lefedettséget. Ha bizonyos fájlokat el kell távolítanod a lefedettségi jelentésből, használd a coverage.exclude opciót.

Ez az egyetlen opció, amely nem írja felül a konfigurációdat, ha CLI flaggel adod meg. Az összes --exclude flaggel hozzáadott glob minta hozzáadódik a konfiguráció exclude listájához.

includeSource

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

Glob minták a forrásban lévő tesztfájlokhoz.

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

name

Típus: string | { label: string, color?: LabelColor }

Egyéni név hozzárendelése a tesztprojekthez vagy a Vitest folyamathoz. A név látható lesz a CLI-ben és a felhasználói felületen, és elérhető lesz a Node.js API-ban a project.name segítségével.

A CLI és a felhasználói felület által használt szín megváltoztatható egy color tulajdonsággal rendelkező objektum megadásával.

server

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

Vite-Node szerver opciók.

server.sourcemap

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

Beágyazott forrástérkép (sourcemap) injektálása a modulokba.

server.debug

Típus: { dumpModules?, loadDumppedModules? }

Vite-Node hibakereső opciók.

server.debug.dumpModules

Típus: boolean | string

A transzformált modul kiírása a fájlrendszerbe. Ha stringet adunk meg, a megadott útvonalra írja ki.

server.debug.loadDumppedModules

Típus: boolean

A kiírt modul beolvasása a fájlrendszerből, ha létezik. Hasznos hibakereséshez a fájlrendszerből származó kiírá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 átadja a csomagot a natív Node-nak. Az externalizált függőségekre nem vonatkoznak a Vite transzformerei és feloldói, így nem támogatják a HMR-t újratöltéskor. Alapértelmezetten a node_modules mappában lévő összes csomag externalizálva van.

Ezek az opciók támogatják a csomagneveket, ahogyan azok a node_modules mappában vannak írva, vagy a deps.moduleDirectories fájlban vannak megadva. Például a @company/some-name csomag, amely a packages/some-name mappában található, some-name néven kell megadni, és a packages mappát bele kell foglalni a deps.moduleDirectories fájlba. 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álunk, a Vitest a fájl elérési útján hívja meg, nem a csomagnéven.

server.deps.inline

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

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

Ha true, minden függőség beágyazásra kerül. Az összes, a ssr.noExternal fájlban megadott függőség alapértelmezetten beágyazásra kerül.

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 az ESM fájlja.

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

server.deps.cacheDir

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

Könyvtár a gyorsítótár fájlok mentéséhez.

deps

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

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

deps.optimizer

Típus: { ssr?, web? }
Lásd még: Függőségoptimalizálási opciók

Függőségoptimalizálás engedélyezése. Ha sok teszted van, ez javíthatja a teljesítményüket.

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

Sok importtal rendelkező csomagok importálása költséges. Egy fájlba csomagolva sok időt takaríthatunk meg.
A felhasználói felület könyvtárainak importálása költséges, mert nem Node.js környezetben való futtatásra készültek.
Az alias konfigurációd mostantól tiszteletben tartott a csomagolt csomagokon belü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 vannak csomagolva (néhány plugin automatikusan feltölti ezt, mint például a Svelte). További információkat az elérhető opciókról a Vite dokumentációjában olvashatsz (a Vitest nem támogatja a disable és noDiscovery opciókat). Alapértelmezetten a Vitest az optimizer.web opciót használja a jsdom és happy-dom környezetekhez, és az optimizer.ssr opciót a node és edge környezetekhez, de ez konfigurálható a transformMode segítségével.

Ez az opció örökli az optimizeDeps konfigurációdat is (web esetén a Vitest kiterjeszti az optimizeDeps-t, ssr esetén az ssr.optimizeDeps-t). Ha újra definiá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 ugyanazokat az opciókat az include listából, ha azok az exclude listában szerepelnek.

TIP

Nem fogod tudni szerkeszteni a node_modules kódodat hibakeresés céljából, mivel a kód valójában a cacheDir vagy test.cache.dir könyvtárban található. Ha console.log utasításokkal szeretnél hibakeresni, szerkeszd közvetlenül, vagy kényszerítsd az újracsomagolást a deps.optimizer?.[mode].force opcióval.

deps.optimizer.{mode}.enabled

Típus: boolean
Alapértelmezett: false

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

deps.web

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

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

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

deps.web.transformAssets

Típus: boolean
Alapértelmezett: true

A Vitestnek fel kell-e dolgoznia az eszközfájlokat (.png, .svg, .jpg stb.) és fel kell-e oldania őket, ahogyan a Vite teszi a böngészőben.

Ez a modul alapértelmezett exportként az eszköz elérési útját fogja tartalmazni, ha nincs megadva lekérdezés.

WARNING

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

deps.web.transformCss

Típus: boolean
Alapértelmezett: true

A Vitestnek fel kell-e dolgoznia a CSS (.css, .scss, .sass stb.) fájlokat és fel kell-e oldania őket, ahogyan a Vite teszi a böngészőben.

Ha a CSS fájlok le vannak tiltva a css opciókkal, ez az opció csak elnyomja az ERR_UNKNOWN_FILE_EXTENSION hibákat.

WARNING

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

deps.web.transformGlobPattern

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

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

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

WARNING

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

deps.interopDefault

Típus: boolean
Alapértelmezett: true

A CJS modul alapértelmezett exportjának értelmezése elnevezett exportként. Néhány függőség csak CJS modulokat csomagol, és nem használ elnevezett exportokat, amelyeket a Node.js statikusan elemezni tud, ha egy csomagot import szintaxissal importálnak a require helyett. Ha ilyen függőségeket importálsz Node környezetben elnevezett exportok használatával, a következő 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 hibát jelezni a futó kód 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értelmezetten a Vitest feltételezi, hogy egy csomagolót használsz ennek megkerülésére, és nem fog hibát jelezni, de ezt a viselkedést manuálisan letilthatod, ha a kódod nincs feldolgozva.

deps.moduleDirectories

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

Azon könyvtárak listája, amelyeket modulkönyvtárként kell kezelni. Ez a konfigurációs opció befolyásolja a vi.mock viselkedését: ha nincs megadva gyár, és a gúnyolt elem elérési útja megegyezik a moduleDirectories egyik értékével, a Vitest megpróbálja feloldani a gúnyolt elemet a projekt gyökerében lévő __mocks__ mappa keresésével.

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értelmezetten 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 szeretnél csomagokat keresni a node_modules mappában, vedd fel azt 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

Útvonal egy egyéni tesztfuttatóhoz. Ez egy haladó funkció, és egyéni könyvtári futtató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 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ásban lévő benchmark tesztfájlokhoz. Ez az opció hasonló az includeSource opcióhoz.

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

benchmark.reporters

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

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

benchmark.outputFile

Elavult a benchmark.outputJson javára.

benchmark.outputJson

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

Fájl elérési útja a benchmark eredmény tárolásához, amely később a --compare opcióhoz használható.

Például:

# save main branch's result
git checkout main
vitest bench --outputJson main.json

# change a branch and compare against main
git checkout feature
vitest bench --compare main.json

benchmark.compare

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

Egy korábbi benchmark eredmény fájl elérési útja, amellyel összehasonlíthatók az aktuális futtatások.

alias

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

Egyéni aliasok definiálása a tesztek futtatásakor. Ezek egyesülnek a resolve.alias aliasokkal.

WARNING

A Vitest Vite SSR primitíveket használ a tesztek futtatásához, aminek bizonyos buktatói vannak.

Az aliasok csak azokra a modulokra vonatkoznak, amelyeket közvetlenül import kulcsszóval importál egy beágyazott modul (alapértelmezetten az összes forráskód beágyazott).
A Vitest nem támogatja a require hívások aliasolását.
Ha egy külső függőséget aliasolsz (pl. react -> preact), érdemes lehet a tényleges node_modules csomagokat aliasolni, hogy működjön az externalizált függőségek esetén. Mind a Yarn, mind a pnpm támogatja az aliasolást az npm: előtaggal.

globals

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

Alapértelmezetten a vitest nem biztosít globális API-kat az egyértelműség kedvéért. 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 opciót a konfigurációhoz.

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

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

Ha már újradefiniáltad a typeRoots beállítást, hogy több típust is tartalmazzon a fordításodban, akkor vissza kell adnod a node_modules fájlt, hogy a vitest/globals felfedezhető legyen.

json

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

Ha már használod az unplugin-auto-import plugint a projektedben, akkor közvetlenül is használhatod az API-k automatikus importálásához.

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

export default defineConfig({
  plugins: [
    AutoImport({
      imports: ['vitest'],
      dts: true, // TypeScript deklaráció generálása
    }),
  ],
});

environment

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

A teszteléshez használt környezet. A Vitest alapértelmezett környezete egy Node.js környezet. Ha webes alkalmazást építesz, használhatsz böngésző-szerű környezetet a jsdom vagy a happy-dom segítségével.

Ha edge funkciókat építesz, használhatod az edge-runtime környezetet.

TIP

Használhatod a Böngésző módot is integrációs vagy egységtesztek futtatására a böngészőben anélkül, hogy a környezetet mockolnád.

Fájl elejére egy @vitest-environment docblock vagy komment hozzáadásával meghatározhatsz egy másik környezetet a fájl összes tesztjéhez:

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 Jesthoz való kompatibilitás érdekében létezik egy @jest-environment is:

/**
 * @jest-environment jsdom
 */

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

Ha a Vitestet a --isolate=false jelzővel futtatod, a tesztek a következő sorrendben futnak: node, jsdom, happy-dom, edge-runtime, egyéni környezetek. Ez azt jelenti, hogy minden ugyanazzal a környezetű teszt csoportosítva van, de továbbra is sorban fut le.

A 0.23.0 verziótól kezdődően egyéni környezetet is definiálhatsz. Amikor beépítettől eltérő környezetet használnak, a Vitest megpróbálja betölteni a vitest-environment-${name} csomagot. Ennek a csomagnak exportálnia kell egy Environment alakú objektumot:

import type { Environment } from 'vitest';

export default <Environment>{
  name: 'custom',
  transformMode: 'ssr',
  setup() {
    // egyéni beállítás
    return {
      teardown() {
        // minden teszt után meghívva, amely ezt a környezetet használta
      },
    };
  },
};

A Vitest a vitest/environments belépési pontján keresztül felfedi a builtinEnvironments lehetőséget is, ha csak bővíteni szeretnéd. Az környezetek bővítéséről többet olvashatsz a útmutatónkban.

TIP

A jsdom környezet felfedi a jsdom globális változót, amely megegyezik az aktuális JSDOM példánnyal. Ha azt szeretnéd, hogy a TypeScript felismerje, hozzáadhatod a vitest/jsdom -t a tsconfig.json fájlhoz, amikor ezt a környezetet használod:

json

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

environmentOptions

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

Ezek az opciók a jelenlegi environment setup metódusának adódnak át. Alapértelmezetten csak a JSDOM opciókat konfigurálhatod, ha azt használod tesztkörnyezetként.

environmentMatchGlobs

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

ELAVULT

Ez az API elavult a Vitest 3-ban. Használja a projekteket a különböző konfigurációk definiálásához.

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

Környezet automatikus hozzárendelése glob minták alapján. Az első találat lesz felhasználva.

Például:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    environmentMatchGlobs: [
      // az összes teszt a tests/dom mappában jsdom környezetben fog futni
      ['tests/dom/**', 'jsdom'],
      // az összes teszt a tests/ mappában .edge.test.ts kiterjesztéssel edge-runtime környezetben fog futni
      ['**/*.edge.test.ts', 'edge-runtime'],
      // ...
    ],
  },
});

poolMatchGlobs

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

ELAVULT

Ez az API elavult a Vitest 3-ban. Használja a projekteket a különböző konfigurációk definiálásához:

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

Automatikusan hozzárendeli a poolt, amelyben a tesztek futni fognak, glob minták alapján. Az első találat lesz felhasználva.

Például:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolMatchGlobs: [
      // a "worker-specific" mappában lévő összes teszt egy worker-ben fog futni, mintha bekapcsolnád nekik a `--pool=threads` opciót,
      ['**/tests/worker-specific/**', 'threads'],
      // Fuss minden "browser" könyvtárban lévő tesztet egy tényleges böngészőben.
      ['**/tests/browser/**', 'browser'],
      // Minden más teszt a "browser.enabled" és "threads" opciók alapján fog futni, ha nem adtál meg más glob-okat.
      // ...
    ],
  },
});

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 && process.stdin.isTTY
CLI: -w, --watch, --watch=false

Figyelő mód engedélyezése

Interaktív környezetekben ez az alapértelmezett, kivéve, ha a --run expliciten meg van adva.

CI-ben, vagy nem interaktív shellből futtatva a "watch" mód nem az alapértelmezett, de expliciten engedélyezhető ezzel a flaggel.

watchTriggerPatterns 3.2.0+ *

Típus: WatcherTriggerPattern[]

A Vitest a modulgráf alapján futtatja újra a teszteket, amelyet statikus és dinamikus import utasítások töltenek fel. Azonban, ha a fájlrendszerből olvasol, vagy proxyból töltesz be, akkor a Vitest nem tudja észlelni ezeket a függőségeket.

A tesztek helyes újrafuttatásához definiálhatsz egy reguláris kifejezés mintát és egy függvényt, amely visszaadja a futtatandó tesztfájlok listáját.

import { defineConfig } from 'vitest/config';

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

WARNING

A visszaadott fájloknak abszolút vagy a gyökérhez képest relatív elérési útnak kell lenniük. Ne feledd, hogy ez egy globális opció, és nem használható projekt konfigurációkban.

root

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

Projekt gyökérkönyvtára

dir

Típus: string
CLI: --dir=<path>
Alapértelmezett: megegyezik a root értékével

Alapkönyvtár a tesztfájlok kereséséhez. Ezt az opciót megadhatod a tesztfelderítés felgyorsításához, ha a gyökér az egész projektet lefedi.

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 jelentéskészítők lehetnek egy Reporter példány, egy string a beépített jelentéskészítők 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

Teszt eredmények fájlba írása, ha a --reporter=json, --reporter=html vagy --reporter=junit opció is meg van adva. Objektum megadásával string helyett egyedi kimeneteket definiálhatsz több jelentéskészítő használatakor.

pool*

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

A tesztek futtatásához használt pool.

threads*

Többszálú végrehajtás engedélyezése a tinypool (a Piscina könnyűsúlyú forkja) segítségével. Szálak használatakor nem használhatók a folyamattal kapcsolatos API-k, mint például 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ákat okozhat több szálon futtatva, és szegmentálási hibákba ütközhet. Ezekben az esetekben javasolt a forks pool használata.

forks*

Hasonlóan a threads poolhoz, de child_process helyett worker_threads használatával a tinypool segítségével. A tesztek és a fő folyamat közötti kommunikáció nem olyan gyors, mint a threads pool esetén. A folyamattal kapcsolatos API-k, mint például a process.chdir(), elérhetők a forks poolban.

vmThreads*

Tesztek futtatása VM környezetben (homokozott környezetben) egy threads poolban.

Ez gyorsabbá teszi a tesztek futását, de a VM modul instabil az ESM kód futtatásakor. A tesztjeid memóriaszivárgást okozhatnak – ennek leküzdésére fontold meg a poolOptions.vmThreads.memoryLimit értékének manuális szerkesztését.

WARNING

A kód homokozóban való futtatásának vannak előnyei (gyorsabb tesztek), de számos hátránya is.

A natív modulokon belüli globális változók (például fs, path stb.) eltérnek a tesztkörnyezetben jelen lévő globális változóktól. Ennek eredményeként az ezekből a natív modulokból származó hibák más 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 kontextusod (tesztfájlod) van. A Node.js-ben nincs olyan API, amely törölné ezt a gyorsítótárat.
A globális változók elérése tovább tart homokozó környezetben.

Kérjük, vedd figyelembe 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.

vmForks*

Hasonlóan a vmThreads poolhoz, de child_process helyett worker_threads használatával a tinypool segítségével. A tesztek és a fő folyamat közötti kommunikáció nem olyan gyors, mint a vmThreads pool esetén. A folyamattal kapcsolatos API-k, mint például a process.chdir(), elérhetők a vmForks poolban. Kérjük, vedd figyelembe, hogy ez a pool ugyanazokkal a buktatókkal rendelkezik, mint a vmThreads.

poolOptions*

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

poolOptions.threads

Opciók a threads poolhoz.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      threads: {
        // Szálakkal kapcsolatos opciók itt
      },
    },
  },
});

poolOptions.threads.maxThreads*

Típus: number | string
Alapértelmezett: elérhető CPU-k

Szálak maximális száma vagy százaléka. Használhatod a VITEST_MAX_THREADS környezeti változót is.

poolOptions.threads.minThreads*

Típus: number | string
Alapértelmezett: elérhető CPU-k

Szálak minimális száma vagy százaléka. Használhatod a VITEST_MIN_THREADS környezeti változót is.

poolOptions.threads.singleThread

Típus: boolean
Alapértelmezett: false

Az összes teszt futtatása ugyanazzal a környezettel egyetlen worker szálon belül. Ez letiltja a beépített modul izolációt (a forráskódod vagy a beágyazott 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ó különbözik a Jest --runInBand opciójától. A Vitest a workereket nemcsak a tesztek párhuzamos futtatására használja, hanem az izoláció biztosítására is. Ennek az opciónak a letiltásával a tesztjeid szekvenciálisan fognak futni, de ugyanabban a globális kontextusban, így magadnak 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 igen), vagy a kódod arra támaszkodik, hogy a környezet minden teszthez külön legyen definiálva. De sebességnövelést jelenthet a tesztjeid számára (akár 3-szor gyorsabb), amelyek nem feltétlenül támaszkodnak globális állapotra, vagy könnyen megkerülhetők.

poolOptions.threads.useAtomics*

Típus: boolean
Alapértelmezett: false

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

Ez bizonyos esetekben javíthatja a teljesítményt, de régebbi Node verziókban szegmentálási hibát okozhat.

poolOptions.threads.isolate

Type: boolean
Default: true

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

poolOptions.threads.execArgv*

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

További argumentumok átadása a node számára a szálakban. További információkért lásd: Command-line API | Node.js.

WARNING

Legyen óvatos a használatával, mivel egyes opciók összeomolhatják a workert, pl. --prof, --title. Lásd: https://github.com/nodejs/node/issues/41103.

poolOptions.forks

Opciók a forks poolhoz.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      forks: {
        // Forkokkal kapcsolatos opciók itt
      },
    },
  },
});

poolOptions.forks.maxForks*

Típus: number | string
Alapértelmezett: elérhető CPU-k

Forkok maximális száma vagy százaléka. Használhatod a VITEST_MAX_FORKS környezeti változót is.

poolOptions.forks.minForks*

Típus: number | string
Alapértelmezett: elérhető CPU-k

Forkok minimális száma vagy százaléka. Használhatod a VITEST_MIN_FORKS környezeti változót is.

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

Az összes teszt futtatása ugyanazzal a környezettel egyetlen gyermekfolyamaton belül. Ez letiltja a beépített modul izolációt (a forráskódod vagy a beágyazott 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ó különbözik a Jest --runInBand opciójától. A Vitest a gyermekfolyamatokat nemcsak a tesztek párhuzamos futtatására használja, hanem az izoláció biztosítására is. Ennek az opciónak a letiltásával a tesztjeid szekvenciálisan fognak futni, de ugyanabban a globális kontextusban, így magadnak kell biztosítanod az izolációt.

poolOptions.forks.execArgv*

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

További argumentumok átadása 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 egyes opciók összeomolhatják a workert, pl. --prof, --title. Lásd: https://github.com/nodejs/node/issues/41103.

poolOptions.vmThreads

Opciók a vmThreads poolhoz.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      vmThreads: {
        // VM szálakkal kapcsolatos opciók itt
      },
    },
  },
});

poolOptions.vmThreads.maxThreads*

Típus: number | string
Alapértelmezett: elérhető CPU-k

Szálak maximális száma vagy százaléka. Használhatod a VITEST_MAX_THREADS környezeti változót is.

poolOptions.vmThreads.minThreads*

Típus: number | string
Alapértelmezett: elérhető CPU-k

Szálak minimális száma vagy százaléka. Használhatod a VITEST_MIN_THREADS környezeti változót is.

poolOptions.vmThreads.memoryLimit*

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

Meghatározza a workerek memóriakorlátját, mielőtt újrahasznosításra kerülnének. Ez az érték nagymértékben függ a környezetedtől, ezért jobb manuálisan megadni, mint az alapértelmezettre támaszkodni.

TIP

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

A korlát többféleképpen is megadható, és bármi is az eredmény, a Math.floor függvényt használják egész számmá alakításához:

<= 1 - Az érték a rendszer memória százalékos arányának tekintendő. Tehát a 0.5 beállítja a worker memóriakorlátját a teljes rendszer memória felére.
> 1 - Rögzített bájtértéknek tekintendő. Az előző szabály miatt, ha 1 bájtos értéket szeretnél (nem tudom miért), használhatod az 1.1-et.
Egységekkel
- 50% - Mint fent, a teljes rendszer memória százalékos aránya.
- 100KB, 65MB, stb. - Egységekkel a rögzített memóriakorlát jelölé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 Linux CircleCI workereken a hibásan jelentett rendszermemória miatt.

poolOptions.vmThreads.useAtomics*

Típus: boolean
Alapértelmezett: false

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

Ez bizonyos esetekben javíthatja a teljesítményt, de régebbi Node verziókban szegmentálási hibát okozhat.

poolOptions.vmThreads.execArgv*

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

További argumentumok átadása a node folyamatnak a VM környezetben. További információkért lásd: Command-line API | Node.js.

WARNING

Legyen óvatos a használatával, mivel egyes opciók összeomolhatják a workert, pl. --prof, --title. Lásd: https://github.com/nodejs/node/issues/41103.

poolOptions.vmForks

Opciók a vmForks poolhoz.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      vmForks: {
        // VM forkokkal kapcsolatos opciók itt
      },
    },
  },
});

poolOptions.vmForks.maxForks*

Típus: number | string
Alapértelmezett: elérhető CPU-k

Forkok maximális száma vagy százaléka. Használhatod a VITEST_MAX_FORKS környezeti változót is.

poolOptions.vmForks.minForks*

Típus: number | string
Alapértelmezett: elérhető CPU-k

Forkok minimális száma vagy százaléka. Használhatod 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 argumentumok átadása a node folyamatnak a VM környezetben. További információkért lásd: Command-line API | Node.js.

WARNING

Legyen óvatos a használatával, mivel egyes opciók összeomolhatják a workert, pl. --prof, --title. Lásd: https://github.com/nodejs/node/issues/41103.

fileParallelism*

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

Minden tesztfájl párhuzamosan fusson-e. Ennek false értékre állítása felülírja a maxWorkers és minWorkers opciókat 1-re.

TIP

Ez az opció nem befolyásolja az ugyanabban a fájlban futó teszteket. Ha azokat párhuzamosan szeretnéd futtatni, használd a concurrent opciót a describe vagy egy konfiguráció segítségével.

maxWorkers*

Típus: number | string

A workerek maximális száma vagy százaléka a tesztek futtatásához. A poolOptions.{threads,vmThreads}.maxThreads/poolOptions.forks.maxForks magasabb prioritással rendelkezik.

minWorkers*

Típus: number | string

A workerek minimális száma vagy százaléka a tesztek futtatásához. A poolOptions.{threads,vmThreads}.minThreads/poolOptions.forks.minForks magasabb prioritással rendelkezik.

testTimeout

Típus: number
Alapértelmezett: 5_000 Node.js-ben, 15_000 ha browser.enabled true
CLI: --test-timeout=5000, --testTimeout=5000

Egy teszt alapértelmezett időtúllépése milliszekundumban. Használj 0-t az időtúllépés teljes letiltásához.

hookTimeout

Típus: number
Alapértelmezett: 10_000 Node.js-ben, 30_000 ha browser.enabled true
CLI: --hook-timeout=10000, --hookTimeout=10000

Egy hook alapértelmezett időtúllépése milliszekundumban. Használj 0-t az időtúllépés teljes letiltásához.

teardownTimeout*

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

Alapértelmezett időtúllépés a bezárásra várva, amikor a Vitest leáll, milliszekundumban.

silent*

Típus: boolean | 'passed-only'
Alapértelmezett: false
CLI: --silent, --silent=false

Csendes konzol kimenet a tesztekből.

Használd a 'passed-only' opciót, hogy csak a sikertelen tesztek naplóit lásd. A sikertelen tesztek naplói a teszt befejezése után kerülnek kinyomtatásra.

setupFiles

Típus: string | string[]

Beállítási fájlok elérési útja. Ezek minden tesztfájl előtt futni fognak.

INFO

Egy beállítási fájl szerkesztése automatikusan elindítja az összes teszt újrafuttatását.

Használhatod a process.env.VITEST_POOL_ID (egész számhoz hasonló string) változót a szálak megkülönböztetésére.

TIP

Ne feledd, hogy ha a --isolate=false opcióval futsz, ez a beállítási fájl többször is futni fog ugyanabban a globális hatókörben. Ez azt jelenti, hogy te magad férsz hozzá ugyanahhoz a globális objektumhoz minden teszt előtt, ezért győződj meg róla, hogy nem csinálsz ugyanazt a dolgot többször, mint amennyire szükséged van.

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-ok minden szvit előtt vissza vannak állítva.
afterEach(() => {
  cleanup();
});

globalThis.resetBeforeEachTest = true;

provide 2.1.0+

Típus: Partial<ProvidedContext>

Definiálj értékeket, amelyek a tesztjeidben az inject metódussal érhetők el.

vitest.config.jsapi.test.js

import { defineConfig } from 'vitest/config';

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

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

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

WARNING

A tulajdonságoknak stringeknek kell lenniük, és az értékeknek szerializálhatónak kell lenniük, mert ez az objektum különböző folyamatok között kerül átvitelre.

TIP

Ha TypeScriptet használsz, a típusbiztos hozzáféréshez ki kell egészítened a ProvidedContext típust:

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

// jelöld meg ezt a fájlt modulként, hogy a kiegészítés megfelelően működjön
export {};

globalSetup

Típus: string | string[]

Globális beállítási fájlok elérési útja, a projekt gyökeréhez képest.

Egy globális beállítási 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 globalSetup fájl is lehetséges. A setup és teardown szekvenciálisan, a teardown fordított sorrendben hajtódik végre.

WARNING

A globális beállítás csak akkor fut le, ha legalább egy futó teszt van. Ez azt jelenti, hogy a globális beállítás elindulhat figyelő módban, miután a tesztfájl megváltozott (a tesztfájl megvárja a globális beállítás befejezését, mielőtt futna).

Vigyázz, hogy a globális beállítás egy másik globális hatókörben fut, így a tesztjeid nem férnek hozzá az itt definiált változókhoz. Azonban szerializálható adatokat átadhatsz a teszteknek a provide metódus segítségével:

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

import { inject } from 'vitest';

inject('wsPort') === 3000;

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

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

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

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

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

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

A Vitest 3 óta definiálhatsz egyéni visszahívó függvényt, amelyet akkor hívunk meg, amikor a Vitest újra futtatja a teszteket. Ha a függvény aszinkron, a futtató megvárja annak befejezését, mielőtt végrehajtaná a teszteket. Ne feledd, hogy a project objektumot nem bonthatod szét, mint { onTestsRerun }, mert az a kontextustól függ.

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

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

forceRerunTriggers*

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

Fájl elérési útjainak glob mintája, amely az egész tesztcsomag újrafuttatását váltja ki. Ha a --changed argumentummal párosítjuk, az egész tesztcsomagot futtatja, ha a trigger megtalálható a git diffben.

Hasznos, ha CLI parancsok hívását teszteléd, mert a Vite nem tud modulgráfot építeni:

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

TIP

Győződj meg róla, hogy a fájljaidat nem zárja ki a server.watch.ignored.

coverage*

Használhatod a v8, istanbul vagy egyéni lefedettségi megoldást a lefedettség gyűjtéséhez.

A lefedettségi opciókat CLI-nek pontjelöléssel adhatod meg:

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

WARNING

Ha pontjelöléssel használod a lefedettségi opciókat, ne felejtsd el megadni a --coverage.enabled opciót. Ebben az esetben ne adj meg egyetlen --coverage opciót sem.

coverage.provider

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

Használd a provider opciót a lefedettség gyűjtéséhez használt eszköz kiválasztásához.

coverage.enabled

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

Lefedettség gyűjtésének engedélyezése. Felülírható a --coverage CLI opcióval.

coverage.include

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

A lefedettségbe bekerülő fájlok listája glob mintákként.

coverage.extension

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

coverage.exclude

Típus: string[]
Alapértelmezett:

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

Elérhető szolgáltatók: 'v8' | 'istanbul'
CLI: --coverage.exclude=<path>, --coverage.exclude=<path1> --coverage.exclude=<path2>

A lefedettségből kizárt fájlok listája glob mintákként.

Ez az opció felülírja az összes alapértelmezett opciót. Bővítsd az alapértelmezett opciókat, amikor új mintákat adsz hozzá az ignoráláshoz:

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

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

MEGJEGYZÉS

A Vitest automatikusan hozzáadja a tesztfájlok include mintáit a coverage.exclude listához. Nem lehetséges a tesztfájlok lefedettségét megjeleníteni.

coverage.all

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

Tartalmazza-e az összes fájlt, beleértve a teszteletleneket is a jelentésbe.

coverage.clean

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

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

coverage.cleanOnRerun

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

Lefedettségi jelentés törlése figyelő módban történő újrafuttatáskor. Állítsd false értékre, hogy megőrizd az előző futtatás lefedettségi eredményeit figyelő módban.

coverage.reportsDirectory

Típus: string
Alapértelmezett: './coverage'
Elérhető szolgáltatók: '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 (alapértelmezett érték).

Könyvtár, ahová a lefedettségi jelentést írni kell.

A lefedettségi jelentés előnézetének megtekintéséhez a HTML jelentéskészítő kimenetében ezt az opciót a html jelentéskönyvtár 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ő szolgáltatók: 'v8' | 'istanbul'
CLI: --coverage.reporter=<reporter>, --coverage.reporter=<reporter1> --coverage.reporter=<reporter2>

Használandó lefedettségi jelentéskészítők. A jelentéskészítők részletes listájáért lásd az istanbul dokumentációját. A jelentéskészítő-specifikus opciókról lásd a @types/istanbul-reporter dokumentációját.

A jelentéskészítőnek három különböző típusa van:

Egyetlen jelentéskészítő: { reporter: 'html' }
Több jelentéskészítő opciók nélkül: { reporter: ['html', 'json'] }

Egy vagy több jelentéskészítő jelentéskészítő opciókkal:

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

Egyéni lefedettségi jelentéskészítőket is átadhatsz. További információkért lásd az Útmutató - Egyéni lefedettségi jelentéskészítő című részt.

{
  reporter: [
    // Jelentéskészítő megadása az NPM csomag nevével
    '@vitest/custom-coverage-reporter',
    ['@vitest/custom-coverage-reporter', { someOption: true }],

    // Jelentéskészítő megadása helyi elérési úttal
    '/absolute/path/to/custom-reporter.cjs',
    ['/absolute/path/to/custom-reporter.cjs', { someOption: true }],
  ];
}

A lefedettségi jelentést a Vitest UI-ban ellenőrizheted: további részletekért lásd a Vitest UI Lefedettség című részt.

coverage.reportOnFailure

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

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

coverage.allowExternal

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

Fájlok lefedettségének gyűjtése a projekt gyökerén kívül.

coverage.excludeAfterRemap 2.1.0+

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

Kizárások újbóli alkalmazása, miután a lefedettség vissza lett térképezve az eredeti forrásokra. Ez akkor hasznos, ha a forrásfájljaid transzpilálva vannak, és nem forrásfájlok forrástérképeit tartalmazhatják.

Használd ezt az opciót, ha olyan fájlokat látsz a jelentésben, amelyek akkor is megjelennek, ha illeszkednek a coverage.exclude mintáidhoz.

coverage.skipFull

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

Ne mutassa a 100%-os utasítás-, elágazás- és függvénylefedettséggel rendelkező fájlokat.

coverage.thresholds

Opciók a lefedettségi küszöbértékekhez.

Ha egy küszöbérték pozitív számra van állítva, akkor az a szükséges lefedettség minimális százalékaként értelmeződik. Például, ha a sorok küszöbértékét 90-re állítjuk, az azt jelenti, hogy a sorok 90%-át le kell fedni.

Ha egy küszöbérték negatív számra van állítva, akkor az a megengedett lefedetlen elemek maximális számaként kezelődik. Például, ha a sorok küszöbértékét -10-re állítjuk, az azt jelenti, hogy legfeljebb 10 sor maradhat lefedetlen.

{
  coverage: {
    thresholds: {
      // Requires 90% function coverage
      functions: 90,

      // Require that no more than 10 lines are uncovered
      lines: -10,
    }
  }
}

coverage.thresholds.lines

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

Globális küszöbérték a sorokhoz.

coverage.thresholds.functions

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

Globális küszöbérték a függvényekhez.

coverage.thresholds.branches

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

Globális küszöbérték az elágazásokhoz.

coverage.thresholds.statements

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

Globális küszöbérték az utasításokhoz.

coverage.thresholds.perFile

Típus: boolean
Alapértelmezett: false
Elérhető szolgáltatók: '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ő szolgáltatók: 'v8' | 'istanbul'
CLI: --coverage.thresholds.autoUpdate=<boolean>

Frissíti az összes küszöbértéket (lines, functions, branches és statements) a konfigurációs fájlban, ha az aktuális lefedettség jobb, mint a konfigurált küszöbértékek. Ez az opció segít fenntartani a küszöbértékeket, amikor a lefedettség javul.

coverage.thresholds.100

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

Globális küszöbértékek beállítása 100-ra. Rövidítés a --coverage.thresholds.lines 100 --coverage.thresholds.functions 100 --coverage.thresholds.branches 100 --coverage.thresholds.statements 100 parancshoz.

coverage.thresholds[glob-pattern]

Típus: { statements?: number functions?: number branches?: number lines?: number }
Alapértelmezett: undefined
Elérhető szolgáltatók: 'v8' | 'istanbul'

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

MEGJEGYZÉS

A Vitest az összes fájlt, beleértve a glob-mintákkal lefedetteket is, beleszámítja a globális lefedettségi küszöbértékekbe. Ez eltér a Jest viselkedésétől.

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

      // Küszöbértékek a glob minta illesztéséhez
      'src/utils/**.ts': {
        statements: 95,
        functions: 90,
        branches: 85,
        lines: 80,
      },

      // Az ennek a mintának megfelelő fájlok csak a sorok küszöbértékeit öröklik.
      // A globális küszöbértékek nem öröklődnek.
      '**/math.ts': {
        lines: 100,
      }
    }
  }
}

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

Típus: boolean
Alapértelmezett: false
Elérhető szolgáltatók: 'v8' | 'istanbul'

Küszöbértékek beállítása 100-ra a glob mintának megfelelő fájlokhoz.

{
  coverage: {
    thresholds: {
      // Az összes fájl küszöbértékei
      functions: 95,
      branches: 70,

      // Küszöbértékek a glob minták illesztéséhez
      'src/utils/**.ts': { 100: true },
      '**/math.ts': { 100: true }
    }
  }
}

coverage.ignoreEmptyLines

Típus: boolean
Alapértelmezett: true (false in v1)
Elérhető szolgáltatók: 'v8'
CLI: --coverage.ignoreEmptyLines=<boolean>

Üres sorok, kommentek és egyéb nem futásidejű kód, pl. Typescript típusok figyelmen kívül hagyása. Ehhez experimentalAstAwareRemapping: false szükséges.

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

Ha más fájlokra is alkalmazni szeretnéd az ESBuild-et, definiáld őket az esbuild opciókban:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  esbuild: {
    // Összes fájl transzpilálása ESBuild-del a kommentek eltávolításához a kódfedettségből.
    // Szükséges a `test.coverage.ignoreEmptyLines` működéséhez:
    include: ['**/*.js', '**/*.jsx', '**/*.mjs', '**/*.ts', '**/*.tsx'],
  },
  test: {
    coverage: {
      provider: 'v8',
      ignoreEmptyLines: true,
    },
  },
});

coverage.experimentalAstAwareRemapping

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

Lefedettség újratérképezése kísérleti AST alapú elemzéssel. Pontosabb eredményeket biztosít az alapértelmezett módhoz képest.

coverage.ignoreClassMethods

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

Osztálymetódusok neveinek tömbje, amelyeket figyelmen kívül kell hagyni a lefedettség szempontjából. 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ók: 'v8' | 'istanbul'
CLI: --coverage.watermarks.statements=50,80, --coverage.watermarks.branches=50,80

Vízjelek utasításokhoz, sorokhoz, elágazásokhoz é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ő szolgáltatók: 'v8' | 'istanbul'
CLI: --coverage.processingConcurrency=<number>

A lefedettségi eredmények feldolgozásakor használt párhuzamossági korlát.

coverage.customProviderModule

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

Meghatározza az egyéni lefedettségi szolgáltató modul nevét vagy elérési útját. További információkért lásd az Útmutató - Egyéni lefedettségi szolgáltató című részt.

testNamePattern*

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

Tesztek futtatása a mintának megfelelő teljes nevekkel. Ha hozzáadod az OnlyRunThis értéket ehhez a tulajdonsághoz, a teszt nevében nem szereplő OnlyRunThis szóval rendelkező tesztek átugrásra kerülnek.

import { expect, test } from 'vitest';

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

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

open*

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

Vitest UI megnyitása (WIP)

api

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

Port figyelése és API szolgáltatása. Ha true értékre van állítva, az alapértelmezett port 51204.

browser kísérleti

Alapértelmezett: { enabled: false }
CLI: --browser=<name>, --browser.name=chrome --browser.headless

Böngésző tesztek futtatásának konfigurációja. Kérjük, tekintse meg a "Böngésző konfigurációs referencia" cikket.

WARNING

Ez egy kísérleti funkció. A változások nem feltétlenül követik a SemVer-t, kérjük, rögzítse a Vitest verzióját, amikor használja.

clearMocks

Típus: boolean
Alapértelmezett: false

Minden kémre meghívja a .mockClear() metódust minden teszt előtt. Ez törli a gúnyolási előzményeket anélkül, hogy befolyásolná a gúnyolási implementációkat.

mockReset

Típus: boolean
Alapértelmezett: false

Minden kémre meghívja a .mockReset() metódust minden teszt előtt. Ez törli a gúnyolási előzményeket és visszaállítja az egyes implementációkat az eredeti állapotukba.

restoreMocks

Típus: boolean
Alapértelmezett: false

Minden kémre meghívja a .mockRestore() metódust minden teszt előtt. Ez törli a gúnyolási előzményeket, visszaállítja az egyes implementációkat az eredeti állapotukba, és visszaállítja a kémkedett objektumok eredeti leíróit.

unstubEnvs

Típus: boolean
Alapértelmezett: false

Minden teszt előtt meghívja a vi.unstubAllEnvs metódust.

unstubGlobals

Típus: boolean
Alapértelmezett: false

Minden teszt előtt meghívja a vi.unstubAllGlobals metódust.

testTransformMode

Típus: { web?, ssr? }

Meghatározza az összes modul transzformációs módszerét, amelyet egy teszten belül importálnak, és amely illeszkedik a glob mintához. Alapértelmezetten a környezettől függ. Például a JSDOM környezetű tesztek az összes fájlt ssr: false flaggel dolgozzák fel, a Node környezetű tesztek pedig az összes modult ssr: true flaggel.

testTransformMode.ssr

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

Használja az SSR transzformációs pipeline-t az összes modulhoz a megadott teszteken belül.
A Vite pluginok ssr: true flaget kapnak ezen fájlok feldolgozásakor.

testTransformMode.web

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

Először végezzen normál transzformációs pipeline-t (böngészőre célozva), majd végezzen SSR újraírást a kód Node-ban való futtatásához.
A Vite pluginok ssr: false flaget kapnak ezen fájlok feldolgozásakor.

snapshotFormat*

Típus: PrettyFormatOptions

Formázási opciók a pillanatkép teszteléshez. Ezek az opciók a pretty-format fájlnak adódnak át.

TIP

Vigyázz, hogy a plugins mező ezen az objektumon figyelmen kívül lesz hagyva.

Ha a pillanatkép szerializálót a pretty-format pluginokon keresztül szeretnéd kiterjeszteni, használd az expect.addSnapshotSerializer API-t vagy a snapshotSerializers opciót.

snapshotSerializers*

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

A pillanatkép szerializáló modulok elérési útjainak listája a pillanatkép teszteléshez, hasznos, ha egyéni pillanatkép szerializálókat szeretnél hozzáadni. További információkért lásd az Egyéni szerializáló című részt.

resolveSnapshotPath*

Típus: (testPath: string, snapExtension: string, context: { config: SerializedConfig }) => string
Alapértelmezett: stores snapshot files in __snapshots__ directory

Felülírja az alapértelmezett pillanatkép elérési utat. Például a tesztfájlok melletti pillanatképek 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 csakként megjelölt teszteket és tesztcsomagokat.

dangerouslyIgnoreUnhandledErrors*

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

Figyelmen kívül hagyja az összes kezeletlen hibát.

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

Heap használat megjelenítése minden teszt után. Hasznos 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ájlokat üres stringekkel helyettesítik, hogy megkerüljék a későbbi feldolgozást. A CSS modulok proxy-t adnak vissza, hogy ne befolyásolják a futásidejű működést.

css.include

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

Reguláris kifejezés minta azokhoz a fájlokhoz, amelyeknek tényleges CSS-t kell visszaadniuk, és amelyeket a Vite pipeline feldolgoz.

TIP

Az összes CSS fájl feldolgozásához használd a /.+/ kifejezést.

css.exclude

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

Reguláris kifejezés 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öntesz, hogy feldolgozod a CSS fájlokat, konfigurálhatod, hogy a CSS modulokon belüli osztálynevek hatókörösek legyenek-e. Választhatsz az alábbi opciók közül:

stable: az osztálynevek _${name}_${hashedFilename} formában generálódnak, ami azt jelenti, hogy a generált osztálynév változatlan marad, ha a CSS tartalom megváltozik, de megváltozik, ha a fájl neve módosul, vagy a fájl másik mappába kerül. Ez a beállítás hasznos, ha pillanatkép funkciót használsz.
scoped: az osztálynevek a szokásos módon generálódnak, tiszteletben tartva a css.modules.generateScopedName metódust, ha van ilyen, és a CSS feldolgozás engedélyezve van. Alapértelmezetten a fájlnév _${name}_${hash} formában generálódik, ahol a hash tartalmazza a fájlnevet és a fájl tartalmát.
non-scoped: az osztálynevek nem lesznek hash-elve.

WARNING

Alapértelmezetten a Vitest egy proxyt exportál, megkerülve a CSS modulok feldolgozását. Ha a CSS tulajdonságokra támaszkodsz az osztályaidban, engedélyezned 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, amelyek egyszerre futhatnak.

Az ezen a korláton felüli tesztek sorba kerülnek, és akkor futnak le, amikor elérhetővé válik egy szabad hely.

cache*

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

Használd ezt az opciót, ha le szeretnéd tiltani a gyorsítótár funkciót. Jelenleg a Vitest a teszteredmények gyorsítótárát tárolja, hogy a hosszabb és sikertelen teszteket futtassa először.

A gyorsítótár könyvtárát a Vite cacheDir opciója vezérli:

import { defineConfig } from 'vitest/config';

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

A könyvtárat csak a Vitest számára korlátozhatod a process.env.VITEST használatával:

import { defineConfig } from 'vitest/config';

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

sequence

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

Opciók a tesztek rendezéséhez.

A sorrend opciókat CLI-nek pontjelöléssel adhatod meg:

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

sequence.sequencer*

Típus: TestSequencerConstructor
Alapértelmezett: BaseSequencer

Egy egyéni osztály, amely a szegmentálási és rendezési metódusokat definiálja. Kiterjesztheted a BaseSequencer osztályt a vitest/node modulból, ha csak a sort és shard metódusok egyikét kell újradefiniálnod, 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.

Ha sequencer.groupOrder meg van adva, a szekvencer minden csoporthoz és poolhoz egyszer hívódik meg.

groupOrder 3.2.0+

Típus: number
Alapértelmezett: 0

Szabályozza a projekt tesztjeinek futtatási sorrendjét több projekt használatakor.

Az azonos csoportsorrendi számmal rendelkező projektek együtt futnak, és a csoportok a legalacsonyabbtól a legmagasabbig futnak.
Ha nem állítod be ezt az opciót, az összes projekt párhuzamosan fut.
Ha több projekt ugyanazt a csoportsorrendet használja, akkor egyszerre fognak futni.

Ez a beállítás csak a projektek futtatási sorrendjét befolyásolja, nem a tesztek sorrendjét egy projekten belül. A tesztizoláció vagy a tesztek sorrendjének szabályozásához egy projekten belül használd az isolate és sequence.sequencer opciókat.

Példa

Tekintsük ezt a példát:

import { defineConfig } from 'vitest/config';

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

A tesztek ezekben a projektekben ebben a sorrendben fognak futni:

 0. slow  |
          |> running together
 0. fast  |

 1. flaky |> runs after slow and fast alone

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 tesztek véletlenszerűen fussanak, engedélyezheted ezt az opciót, vagy a CLI argumentumot --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 indulnak – ez gyorsabbá teszi a tesztek futását. Ha a fájljaid és tesztjeid véletlenszerű sorrendben futnak, elveszíted ezt a teljesítményjavulást, de hasznos lehet olyan tesztek nyomon követésére, amelyek véletlenül egy korábban futott teszttől függenek.

sequence.shuffle.files

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

Fájlok véletlenszerű sorrendbe állítása, vedd figyelembe, hogy a hosszú ideig futó tesztek nem indulnak korábban, ha engedélyezed ezt az opciót.

sequence.shuffle.tests

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

Tesztek véletlenszerű sorrendbe állítása.

sequence.concurrent

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ót, vagy a CLI argumentumot --sequence.concurrent.

sequence.seed*

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

Beállítja a randomizálási magot, ha a tesztek véletlenszerű sorrendben futnak.

sequence.hooks

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

Megváltoztatja a hookok végrehajtási sorrendjét.

A stack fordított sorrendben rendezi az "after" hookokat, a "before" hookok abban a sorrendben futnak, ahogyan definiálva lettek.
A list az összes hookot abban a sorrendben rendezi, ahogyan definiálva lettek.
A parallel egyetlen csoportban párhuzamosan futtatja a hookokat (a szülő suite-okban lévő hookok továbbra is a jelenlegi suite hookjai előtt futnak).

TIP

Ez az opció nem befolyásolja az onTestFinished metódust. Az mindig fordított sorrendben hívódik meg.

sequence.setupFiles

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

Megváltoztatja a beállítási fájlok végrehajtási sorrendjét.

A list a beállítási fájlokat abban a sorrendben futtatja, ahogyan definiálva lettek.
A parallel párhuzamosan futtatja a beállítási fájlokat.

typecheck

Opciók a típusellenőrzési tesztkörnyezet konfigurálásához.

typecheck.enabled

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

Típusellenőrzés engedélyezése a szokásos tesztjeid mellett.

typecheck.only

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

Csak típusellenőrzési tesztek futtatása, ha a típusellenőrzés engedélyezve van. 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özöket használjon a típusellenőrzéshez. A Vitest bizonyos paraméterekkel indít egy folyamatot a könnyebb elemzés érdekében, a típustól függően. Az ellenőrzőnek ugyanazt a kimeneti formátumot kell implementálnia, mint a tsc.

A típusellenőrző használatához telepítened kell egy csomagot:

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

Átadhatsz egy elérési utat egy egyéni bináris fájlhoz vagy parancsnévhez is, amely ugyanazt a kimenetet produká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 kezelendő fájlokhoz.

typecheck.exclude

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

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

typecheck.allowJs

Típus: boolean
Alapértelmezett: false

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

typecheck.ignoreSourceErrors

Típus: boolean
Alapértelmezett: false

Ne hibázzon, ha a Vitest hibákat talál a tesztfájlokon kívül. Ez egyáltalán nem fogja megmutatni a nem tesztelési hibákat.

Alapértelmezetten, ha a Vitest forráshibát talál, a tesztcsomag hibát jelez.

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 képest.

typecheck.spawnTimeout

Típus: number
Alapértelmezett: 10_000

Minimális idő milliszekundumban, amíg a típusellenőrző elindul.

slowTestThreshold*

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

Az a milliszekundumban megadott szám, amely után egy teszt vagy tesztcsomag lassúnak minősül, és így jelentésre kerül az eredményekben.

chaiConfig

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

A Chai config megfelelője.

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 érték elnyomja a veremkövetést a hibaüzenetben.

chaiConfig.showDiff

Típus: boolean
Alapértelmezett: true

Befolyásolja, hogy a showDiff flag szerepeljen-e a dobott 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 hosszúsági küszöbét az állítási hibákban. Ha ez a küszöb túllépésre kerül, például nagy adatstruktúrák esetén, az érték helyébe valami olyasmi lép, mint [ Array(3) ] vagy { Object (prop1, prop2) }. Állítsd 0-ra, ha teljesen le szeretnéd 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üzenetben.

bail

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

Tesztvégrehajtás leállítása, ha a megadott számú teszt sikertelen.

Alapértelmezetten a Vitest az összes tesztesetedet futtatja, még akkor is, ha némelyikük sikertelen. Ez nem kívánatos lehet CI build-ek esetén, ahol csak a 100%-ban sikeres build-ek érdekelnek, és szeretnéd a lehető legkorábban leállítani a tesztvégrehajtást, ha teszthibák léptek fel. A bail opció használható a CI futtatások felgyorsítására azáltal, hogy megakadályozza további tesztek futtatását, ha hibák léptek fel.

retry

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

A teszt újrapróbálása a megadott számú alkalommal, ha sikertelen.

onConsoleLog*

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

Egyéni kezelő a console.log számára a tesztekben. Ha false értéket adsz vissza, a Vitest nem fogja kinyomtatni a naplót a konzolra.

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

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*

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

Szűrőfüggvény alkalmazása minden veremkövetés minden keretére a hibák kezelésekor. Az első argumentum, az error, egy objektum, amelynek tulajdonságai megegyeznek egy szabványos Error tulajdonságaival, de nem tényleges példány.

Hasznos lehet harmadik féltől származó könyvtárak veremkövetési kereteinek szű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-tal találkoztunk, mutasd meg a teljes verem (stack) tartalmát.
      if (error.name === 'ReferenceError') {
        return;
      }

      // Elutasít minden keretet harmadik féltől származó könyvtárakból.
      if (file.includes('node_modules')) {
        return false;
      }
    },
  },
});

diff

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

DiffOptions objektum vagy egy modul elérési útja, amely DiffOptions-t exportál. Hasznos, ha testre szeretnéd szabni a diff megjelenítését.

Például, mint konfigurációs objektum:

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

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

Vagy modulként:

vitest.config.jsvitest.diff.ts

import { defineConfig } from 'vitest/config';

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

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

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

diff.expand

Típus: boolean
Alapértelmezett: true
CLI: --diff.expand=false

Az összes közös sor kibontása.

diff.truncateThreshold

Típus: number
Alapértelmezett: 0
CLI: --diff.truncateThreshold=<path>

A megjelenítendő diff eredmény maximális hossza. Az ezen a küszöbön felüli diffek csonkításra kerülnek. A csonkítás nem lép életbe az alapértelmezett 0 értékkel.

diff.truncateAnnotation

Típus: string
Alapértelmezett: '... Diff result is truncated'
CLI: --diff.truncateAnnotation=<annotation>

Annotáció, amely a diff eredmény végén jelenik meg, ha az csonkítva van.

diff.truncateAnnotationColor

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

A csonkítási annotáció színe, alapértelmezetten színtelen kimenet.

diff.printBasicPrototype

Típus: boolean
Alapértelmezett: false

Alapvető prototípus Object és Array kinyomtatása a diff kimenetben.

diff.maxDepth

Típus: number
Alapértelmezett: 20 (vagy 8 különböző típusok összehasonlításakor)

Korlátozza a beágyazott objektumok kiírásakor a rekurzió mélységét.

fakeTimers

Típus: FakeTimerInstallOpts

Opciók, amelyeket a Vitest átad a @sinon/fake-timers modulnak a vi.useFakeTimers() használatakor.

fakeTimers.now

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

Hamis időzítők telepítése a megadott Unix epoch-val.

fakeTimers.toFake

Típus: ('setTimeout' | 'clearTimeout' | 'setImmediate' | 'clearImmediate' | 'setInterval' | 'clearInterval' | 'Date' | 'nextTick' | 'hrtime' | 'requestAnimationFrame' | 'cancelAnimationFrame' | 'requestIdleCallback' | 'cancelIdleCallback' | 'performance' | 'queueMicrotask')[]
Alapértelmezett: minden globálisan elérhető, kivéve a nextTick és queueMicrotask

Globális metódusok és API-k neveinek tömbje, amelyeket hamisítani kell.

Csak a setTimeout() és nextTick() gúnyolásához add meg ezt a tulajdonságot ['setTimeout', 'nextTick'] formában.

A nextTick gúnyolása nem támogatott, ha a Vitestet node:child_process környezetben futtatod a --pool=forks használatával. NodeJS uses process.nextTick internally in node:child_process and hangs when it is mocked. Mocking nextTick is supported when running Vitest with --pool=threads.

fakeTimers.loopLimit

Típus: number
Alapértelmezett: 10_000

A vi.runAllTimers() hívásakor futtatandó időzítők maximális száma.

fakeTimers.shouldAdvanceTime

Típus: boolean
Alapértelmezett: false

Megmondja a @sinonjs/fake-timers-nek, hogy automatikusan növelje a gúnyolt időt a valós rendszeridő eltolódása alapján (pl. a gúnyolt idő 20ms-mal növekszik minden 20ms-os valós rendszeridő változás esetén).

fakeTimers.advanceTimeDelta

Típus: szám
Alapértelmezett: 20

Csak akkor releváns, ha shouldAdvanceTime: true opcióval használod. A valós rendszeridő minden advanceTimeDelta ms változása után növeli a mockolt időt advanceTimeDelta ms-sel.

fakeTimers.shouldClearNativeTimers

Típus: boolean
Alapértelmezett: true

Megadja a hamis időzítőknek, hogy töröljék a "natív" (azaz nem hamis) időzítőket a megfelelő kezelőik delegálásával. Ha letiltva van, váratlan viselkedéshez vezethet, ha az időzítők léteztek a hamis időzítők munkamenetének indítása előtt.

workspace*

ELAVULT

Ez az opció elavult, és a következő főverzióban eltávolításra kerül. Kérlek, használd helyette a projects opciót.

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

Útvonal egy munkaterület konfigurációs fájlhoz a gyökér könyvtárhoz viszonyítva.

Vitest 3 óta a munkaterület tömböt a gyökér konfigurációban is definiálhatod. Ha a workspace manuálisan van definiálva a konfigurációban, a Vitest figyelmen kívül hagyja a vitest.workspace fájlt a gyökér könyvtárban.

projects*

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

Projektek tömbje.

isolate

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

Teszt futtatása izolált környezetben. Ennek az opciónak nincs hatása a vmThreads és vmForks poolokra.

Ennek az opcionak a letiltása javíthatja a teljesítményt, ha a kódod nem függ mellékhatásoktól (ami általában igaz a node környezetű projektekre).

TIP

Letilthatod az izolációt bizonyos poolok számára a poolOptions tulajdonság használatával.

includeTaskLocation

Típus: boolean
Alapértelmezett: false

Szerepeltetni kell-e a location tulajdonságot, amikor a Vitest API feladatokat kap a riporterektől. Ha sok teszted van, ez kisebb teljesítménycsökkenést okozhat.

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

Ez az opció automatikusan engedélyezésre kerül, ha nem tiltod le explicit módon, és a Vitest-et a következővel futtatod:

Vitest UI
vagy a Böngésző mód használatával fej nélküli mód nélkül
vagy a HTML riporter használatával

TIP

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

snapshotEnvironment

Típus: string

Útvonal egy egyéni snapshot környezet implementációjához. 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őfutóra.

Ennek az objektumnak rendelkeznie kell a SnapshotEnvironment alakjával, és a snapshot fájlok feloldására és olvasására/í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 objektumot 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ó, és csak haladó esetekben szabad használni, ahol 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 resolveSnapshotPath opciókat.

env

Típus: Partial<NodeJS.ProcessEnv>

Környezeti változók, amelyek elérhetők a process.env-en és az import.meta.env-en a tesztek futása közben. Ezek a változók nem lesznek elérhetők a fő folyamatban (például a globalSetup-ban).

expect

Típus: ExpectOptions

expect.requireAssertions

Típus: boolean
Alapértelmezett: false

Ugyanaz, mint a expect.hasAssertions() hívása minden teszt elején. Ez biztosítja, hogy egyetlen teszt se menjen át véletlenül.

TIP

Ez csak a Vitest expect objektumával működik. Ha assert vagy .should kijelentéseket használsz, azok nem számítanak bele, és a teszted sikertelen lesz az expect kijelentések hiánya miatt.

Ennek értékét megváltoztathatod a vi.setConfig({ expect: { requireAssertions: false } }) hívásával. A konfiguráció minden következő expect hívásra alkalmazódik, amíg a vi.resetConfig manuálisan meg nem hívásra kerül.

expect.poll

Globális konfigurációs opciók az expect.poll számára. Ezek ugyanazok az opciók, amelyeket átadhatsz az expect.poll(condition, options) hívásnak.

expect.poll.interval

Típus: szám
Alapértelmezett: 50

Lekérdezési időköz milliszekundumban

expect.poll.timeout

Típus: szám
Alapértelmezett: 1000

Lekérdezési időtúllépés milliszekundumban

printConsoleTrace

Típus: boolean
Alapértelmezett: false

Mindig nyomtassa ki a konzol nyomkövetéseket, amikor bármilyen console metódust hívnak. Ez hasznos a hibakereséshez.

attachmentsDir 3.2.0+

Típus: string
Alapértelmezett: '.vitest-attachments'

Könyvtárútvonal a context.annotate által létrehozott mellékletek tárolásához a projekt gyökérhez képest.

Vitest konfigurálása ​

include ​

exclude ​

includeSource ​

name ​

server ​

server.sourcemap ​

server.debug ​

server.debug.dumpModules ​

server.debug.loadDumppedModules ​

server.deps ​

server.deps.external ​

server.deps.inline ​

server.deps.fallbackCJS ​

server.deps.cacheDir ​

deps ​

deps.optimizer ​

deps.optimizer.{mode}.enabled ​

deps.web ​

deps.web.transformAssets ​

deps.web.transformCss ​

deps.web.transformGlobPattern ​

deps.interopDefault ​

deps.moduleDirectories ​

runner ​

benchmark ​

benchmark.include ​

benchmark.exclude ​

benchmark.includeSource ​

benchmark.reporters ​

benchmark.outputFile ​

benchmark.outputJson ​

benchmark.compare ​

alias ​

globals ​

environment ​

environmentOptions ​

environmentMatchGlobs ​

poolMatchGlobs ​

update* ​

watch* ​

watchTriggerPatterns 3.2.0+ * ​

root ​

dir ​

reporters* ​

outputFile* ​

pool* ​

threads* ​

forks* ​

vmThreads* ​

vmForks* ​

poolOptions* ​

poolOptions.threads ​

poolOptions.threads.maxThreads* ​

poolOptions.threads.minThreads* ​

poolOptions.threads.singleThread ​

poolOptions.threads.useAtomics* ​

poolOptions.threads.isolate ​

poolOptions.threads.execArgv* ​

poolOptions.forks ​

poolOptions.forks.maxForks* ​

poolOptions.forks.minForks* ​

poolOptions.forks.isolate ​

poolOptions.forks.singleFork ​

poolOptions.forks.execArgv* ​

poolOptions.vmThreads ​

poolOptions.vmThreads.maxThreads* ​

poolOptions.vmThreads.minThreads* ​

poolOptions.vmThreads.memoryLimit* ​

poolOptions.vmThreads.useAtomics* ​

poolOptions.vmThreads.execArgv* ​

poolOptions.vmForks ​

poolOptions.vmForks.maxForks* ​

poolOptions.vmForks.minForks* ​

poolOptions.vmForks.memoryLimit* ​

poolOptions.vmForks.execArgv* ​

fileParallelism* ​

maxWorkers* ​

minWorkers* ​

testTimeout ​

Vitest konfigurálása

include

exclude

includeSource

name

server

server.sourcemap

server.debug

server.debug.dumpModules

server.debug.loadDumppedModules

server.deps

server.deps.external

server.deps.inline

server.deps.fallbackCJS

server.deps.cacheDir

deps

deps.optimizer

deps.optimizer.{mode}.enabled

deps.web

deps.web.transformAssets

deps.web.transformCss

deps.web.transformGlobPattern

deps.interopDefault

deps.moduleDirectories

runner

benchmark

benchmark.include

benchmark.exclude

benchmark.includeSource

benchmark.reporters

benchmark.outputFile

benchmark.outputJson

benchmark.compare

alias

globals

environment

environmentOptions

environmentMatchGlobs

poolMatchGlobs

update*

watch*

watchTriggerPatterns 3.2.0+ *

root

dir

reporters*

outputFile*

pool*

threads*

forks*

vmThreads*

vmForks*

poolOptions*

poolOptions.threads

poolOptions.threads.maxThreads*

poolOptions.threads.minThreads*

poolOptions.threads.singleThread

poolOptions.threads.useAtomics*

poolOptions.threads.isolate

poolOptions.threads.execArgv*

poolOptions.forks

poolOptions.forks.maxForks*

poolOptions.forks.minForks*

poolOptions.forks.isolate

poolOptions.forks.singleFork

poolOptions.forks.execArgv*

poolOptions.vmThreads

poolOptions.vmThreads.maxThreads*

poolOptions.vmThreads.minThreads*

poolOptions.vmThreads.memoryLimit*

poolOptions.vmThreads.useAtomics*

poolOptions.vmThreads.execArgv*

poolOptions.vmForks

poolOptions.vmForks.maxForks*

poolOptions.vmForks.minForks*

poolOptions.vmForks.memoryLimit*

poolOptions.vmForks.execArgv*

fileParallelism*

maxWorkers*

minWorkers*

testTimeout