Configurazione di Vitest

Per creare un file di configurazione Vitest, segui la guida. Assicurati di aver compreso il meccanismo di risoluzione della configurazione di Vitest prima di procedere.

WARNING

Tutte le opzioni elencate qui si trovano all'interno della proprietà test nella configurazione:

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

TIP

Oltre alle opzioni seguenti, puoi utilizzare qualsiasi opzione di configurazione di Vite. Ad esempio, define per definire variabili globali o resolve.alias per definire alias.

Le opzioni di configurazione non supportate all'interno di una configurazione di progetto workspace sono contrassegnate con il simbolo *.

include

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

Un elenco di pattern glob che specificano i file di test da includere.

exclude

Tipo: string[]
Predefinito: ['**/node_modules/**', '**/dist/**', '**/cypress/**', '**/.{idea,git,cache,output,temp}/**', '**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build}.config.*']
CLI: vitest --exclude "**/excluded-file"

Un elenco di pattern glob che specificano i file di test da escludere.

WARNING

Questa opzione non influisce sulla copertura del codice. Per escludere file dal report di coverage, usa coverage.exclude.

Questa è l'unica opzione che, se fornita tramite flag CLI, aggiunge i pattern alla configurazione esistente, anziché sovrascriverla. Tutti i pattern glob aggiunti tramite il flag --exclude verranno aggiunti all'exclude della configurazione.

includeSource

Tipo: string[]
Predefinito: []

Include glob per i file di test nel codice sorgente.

Se definita, Vitest eseguirà tutti i file corrispondenti che contengono import.meta.vitest.

server 0.34.0+

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

Opzioni per il server Vite-Node.

server.sourcemap

Tipo: 'inline' | boolean
Predefinito: 'inline'

Inietta la sourcemap inline nei moduli.

server.debug

Tipo: { dumpModules?, loadDumppedModules? }

Opzioni per il debugger Vite-Node.

server.debug.dumpModules

Tipo: boolean | string

Salva i moduli trasformati nel filesystem. Se si passa una stringa, i moduli verranno salvati nel percorso specificato.

server.debug.loadDumppedModules

Tipo: boolean

Carica i moduli salvati dal filesystem, se esistenti. Utile per il debug modificando il risultato del dump nel filesystem.

server.deps

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

Gestione della risoluzione delle dipendenze.

server.deps.external

Tipo: (string | RegExp)[]
Predefinito: [/\/node_modules\//]

L'esternalizzazione indica che Vite ignorerà il bundling e passerà la dipendenza a Node nativo. Le dipendenze esternalizzate non verranno elaborate dai transformer e dai resolver di Vite, quindi non supporteranno l'HMR (Hot Module Replacement) al ricaricamento. Per impostazione predefinita, tutti i pacchetti all'interno di node_modules sono esternalizzati.

Queste opzioni supportano i nomi dei pacchetti così come sono scritti in node_modules o specificati all'interno di deps.moduleDirectories. Ad esempio, il pacchetto @company/some-name situato all'interno di packages/some-name deve essere specificato come some-name e packages deve essere incluso in deps.moduleDirectories. Fondamentalmente, Vitest controlla sempre il percorso del file, non il nome effettivo del pacchetto.

Se viene utilizzata un'espressione regolare (regexp), Vitest la applica al percorso del file, non al nome del pacchetto.

server.deps.inline

Tipo: (string | RegExp)[] | true
Predefinito: []

Vite elaborerà i moduli inlined. Questo può essere utile per gestire i pacchetti che forniscono .js in formato ESM (che Node non può gestire).

Se true, ogni dipendenza verrà inlined. Tutte le dipendenze specificate in ssr.noExternal verranno inlined per impostazione predefinita.

server.deps.fallbackCJS

Tipo boolean
Predefinito: false

Quando una dipendenza è un pacchetto ESM valido, prova a dedurre la versione CJS in base al percorso. Questo può essere utile se una dipendenza presenta un file ESM errato.

Ciò potrebbe potenzialmente causare un disallineamento se un pacchetto ha una logica diversa in modalità ESM e CJS.

server.deps.cacheDir

Tipo string
Predefinito: 'node_modules/.vite'

Directory per salvare i file di cache.

deps

Tipo: { optimizer?, ... }

Gestione della risoluzione delle dipendenze.

deps.optimizer 0.34.0+

Tipo: { ssr?, web? }
Vedi anche: Opzioni di ottimizzazione delle dipendenze

Abilita l'ottimizzazione delle dipendenze. Se hai molti test, questo può migliorare le prestazioni. Prima di Vitest 0.34.0, era denominato deps.experimentalOptimizer.

Quando Vitest rileva una libreria esterna elencata in include, verrà raggruppata in un singolo file tramite esbuild e importata come un modulo completo. Questo è vantaggioso per diversi motivi:

Importare pacchetti con molte importazioni è oneroso. Raggruppandoli in un unico file si può risparmiare molto tempo.
L'importazione di librerie UI è costosa perché non sono pensate per essere eseguite all'interno di Node.js.
La configurazione alias viene ora rispettata all'interno dei pacchetti raggruppati.
Il codice nei test viene eseguito in un ambiente più simile a quello del browser.

Tieni presente che solo i pacchetti nell'opzione deps.optimizer?.[mode].include sono raggruppati (alcuni plugin lo popolano automaticamente, come Svelte). Puoi leggere ulteriori informazioni sulle opzioni disponibili nella documentazione di Vite (Vitest non supporta le opzioni disable e noDiscovery). Per impostazione predefinita, Vitest utilizza optimizer.web per gli ambienti jsdom e happy-dom e optimizer.ssr per gli ambienti node e edge, ma è configurabile tramite transformMode.

Queste opzioni ereditano anche la configurazione optimizeDeps (per web Vitest estenderà optimizeDeps, per ssr - ssr.optimizeDeps). Se ridefinisci l'opzione include/exclude in deps.optimizer, estenderà il tuo optimizeDeps durante l'esecuzione dei test. Vitest rimuove automaticamente le stesse opzioni da include, se sono elencate in exclude.

TIP

Non potrai modificare il codice in node_modules per il debug, poiché si troverà nella directory cacheDir o test.cache.dir. Se vuoi eseguire il debug con istruzioni console.log, modificalo direttamente o forza il rebundling con l'opzione deps.optimizer?.[mode].force.

deps.optimizer.{mode}.enabled

Tipo: boolean
Predefinito: false da Vitest 1.3.0

Abilita l'ottimizzazione delle dipendenze.

WARNING

Questa opzione è valida solo per Vite 4.3.2 e versioni successive.

deps.web 0.34.2+

Tipo: { transformAssets?, ... }

Opzioni che vengono applicate ai file esterni quando la modalità di trasformazione è impostata su web. Per impostazione predefinita, jsdom e happy-dom utilizzano la modalità web, mentre gli ambienti node e edge utilizzano la modalità di trasformazione ssr, quindi queste opzioni non avranno alcun effetto sui file all'interno di tali ambienti.

Di solito, i file all'interno di node_modules sono esternalizzati, ma queste opzioni influenzano anche i file in server.deps.external.

deps.web.transformAssets

Tipo: boolean
Predefinito: true

Vitest elabora i file di risorse (.png, .svg, .jpg, ecc.) e li risolve come fa Vite nel browser.

Questo modulo avrà un'esportazione predefinita corrispondente al percorso della risorsa, se non viene specificata alcuna query.

WARNING

Al momento, questa opzione funziona solo con i pool vmThreads e vmForks.

deps.web.transformCss

Tipo: boolean
Predefinito: true

Vitest elabora i file CSS (.css, .scss, .sass, ecc.) e li risolve come fa Vite nel browser.

Se i file CSS sono disabilitati tramite le opzioni css, questa opzione silenzierà gli errori ERR_UNKNOWN_FILE_EXTENSION.

WARNING

Al momento, questa opzione funziona solo con i pool vmThreads e vmForks.

deps.web.transformGlobPattern

Tipo: RegExp | RegExp[]
Predefinito: []

Pattern RegExp per i file esterni da trasformare.

Per impostazione predefinita, i file all'interno di node_modules sono esternalizzati e non trasformati, a meno che non si tratti di CSS o di una risorsa e l'opzione corrispondente non sia disabilitata.

WARNING

Al momento, questa opzione funziona solo con i pool vmThreads e vmForks.

deps.interopDefault

Tipo: boolean
Predefinito: true

Considera il default del modulo CJS come esportazioni denominate. Alcune dipendenze raggruppano solo moduli CJS e non espongono esportazioni denominate che Node.js può analizzare staticamente quando un pacchetto viene importato tramite import anziché require. Quando si importano tali dipendenze nell'ambiente Node utilizzando esportazioni denominate, verrà visualizzato questo errore:

import { read } from 'fs-jetpack';
         ^^^^
SyntaxError: Named export 'read' not found. The requested module 'fs-jetpack' is a CommonJS module, which may not support all module.exports as named exports.
CommonJS modules can always be imported via the default export.

Vitest non esegue analisi statica e non può rilevare l'errore prima dell'esecuzione del codice. Pertanto, se questa funzionalità è disabilitata, l'errore si presenterà durante l'esecuzione dei test:

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

Per impostazione predefinita, Vitest presuppone che tu stia utilizzando un bundler per aggirare questo problema e non fallirà, ma puoi disabilitare manualmente questo comportamento se il tuo codice non viene elaborato.

deps.moduleDirectories

Tipo: string[]
Predefinito: ['node_modules']

Un elenco di directory che devono essere trattate come directory di moduli. Questa opzione di configurazione influisce sul comportamento di vi.mock: quando non viene fornita alcuna factory e il percorso di ciò che stai mockando corrisponde a uno dei valori moduleDirectories, Vitest proverà a risolvere il mock cercando una cartella __mocks__ nella root del progetto.

Questa opzione influenzerà anche la modalità in cui i file vengono trattati come moduli durante l'esternalizzazione delle dipendenze. Per impostazione predefinita, Vitest importa moduli esterni con Node.js nativo bypassando la fase di trasformazione di Vite.

Impostando questa opzione sovrascriverai il valore predefinito; se desideri comunque cercare pacchetti in node_modules, includila insieme a qualsiasi altra opzione:

import { defineConfig } from 'vitest/config';

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

runner

Tipo: VitestRunnerConstructor
Predefinito: node, quando si eseguono test, o benchmark, quando si eseguono benchmark

Percorso per un test runner personalizzato. Questa è una funzionalità avanzata e dovrebbe essere utilizzata con runner di librerie personalizzate. Puoi trovare maggiori informazioni nella documentazione.

benchmark

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

Opzioni utilizzate quando si esegue vitest bench.

benchmark.include

Tipo: string[]
Predefinito: ['**/*.{bench,benchmark}.?(c|m)[jt]s?(x)']

Pattern glob per includere i file di benchmark.

benchmark.exclude

Tipo: string[]
Predefinito: ['node_modules', 'dist', '.idea', '.git', '.cache']

Pattern glob per escludere i file di benchmark.

benchmark.includeSource

Tipo: string[]
Predefinito: []

Include glob per i file di benchmark in-source. Questa opzione è simile a includeSource.

Se definita, Vitest eseguirà tutti i file corrispondenti che contengono import.meta.vitest.

benchmark.reporters

Tipo: Arrayable<BenchmarkBuiltinReporters | Reporter>
Predefinito: 'default'

Reporter personalizzati per l'output. Può contenere uno o più nomi di report integrati, istanze di reporter e/o percorsi a reporter personalizzati.

benchmark.outputFile

Tipo: string | Record<string, string>

Scrive i risultati del benchmark in un file quando viene specificata anche l'opzione --reporter=json. Fornendo un oggetto anziché una stringa, puoi definire output individuali quando utilizzi più reporter.

Per fornire un oggetto tramite il comando CLI, usa la seguente sintassi: --outputFile.json=./path --outputFile.junit=./other-path.

benchmark.outputJson 1.6.0+

Tipo: string | undefined
Predefinito: undefined

Un percorso di file per memorizzare il risultato del benchmark, utilizzabile per l'opzione --compare in seguito.

Per esempio:

# salva il risultato del branch principale
git checkout main
vitest bench --outputJson main.json

# cambia un branch e confronta con main
git checkout feature
vitest bench --compare main.json

benchmark.compare 1.6.0+

Tipo: string | undefined
Predefinito: undefined

Un percorso di file contenente un risultato di benchmark precedente, da confrontare con le esecuzioni attuali.

alias

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

Definisce alias personalizzati durante l'esecuzione all'interno dei test. Verranno uniti agli alias da resolve.alias.

WARNING

Vitest utilizza le primitive Vite SSR per l'esecuzione dei test, il che comporta alcune insidie.

Gli alias influiscono solo sui moduli importati direttamente con una parola chiave import da un modulo inlined (tutto il codice sorgente è inlined per impostazione predefinita).
Vitest non supporta l'aliasing delle chiamate require.
Se stai creando un alias per una dipendenza esterna (ad esempio, react -> preact), potresti voler creare un alias per i pacchetti node_modules effettivi, in modo che funzioni anche per le dipendenze esternalizzate. Sia Yarn che pnpm supportano l'aliasing tramite il prefisso npm:.

globals

Tipo: boolean
Predefinito: false
CLI: --globals, --globals=false

Per impostazione predefinita, vitest non espone API globali per maggiore chiarezza. Se preferisci utilizzare le API globalmente come Jest, puoi passare l'opzione --globals alla CLI o aggiungere globals: true nella configurazione.

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

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

Per abilitare il supporto TypeScript per le API globali, aggiungi vitest/globals al campo types nel file tsconfig.json.

json

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

Se nel tuo progetto è già presente unplugin-auto-import, puoi utilizzarlo direttamente per importare automaticamente queste API.

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

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

environment

Tipo: 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime' | string
Predefinito: 'node'
CLI: --environment=<env>

Definisce l'ambiente di esecuzione per i test. L'ambiente predefinito di Vitest è Node.js. Per lo sviluppo di applicazioni web, è possibile utilizzare un ambiente che simula un browser tramite jsdom o happy-dom. Per funzioni edge, è disponibile l'ambiente edge-runtime.

È possibile specificare un ambiente diverso per un singolo file di test aggiungendo un blocco doc o un commento @vitest-environment all'inizio del file:

Formato blocco doc:

/**
 * @vitest-environment jsdom
 */

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

Formato commento:

// @vitest-environment happy-dom

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

Per compatibilità con Jest, è supportato anche @jest-environment:

/**
 * @jest-environment jsdom
 */

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

Se Vitest viene eseguito con il flag --isolate=false, i test verranno eseguiti nel seguente ordine: node, jsdom, happy-dom, edge-runtime, custom environments (ambienti personalizzati). I test con lo stesso ambiente vengono raggruppati, ma eseguiti in sequenza.

Dalla versione 0.23.0, è possibile definire ambienti personalizzati. Quando si utilizza un ambiente non predefinito, Vitest tenterà di caricare il pacchetto vitest-environment-${name}. Questo pacchetto deve esportare un oggetto conforme alla forma Environment:

import type { Environment } from 'vitest';

export default <Environment>{
  name: 'custom',
  transformMode: 'ssr',
  setup() {
    // configurazione personalizzata
    return {
      teardown() {
        // chiamato dopo l'esecuzione di tutti i test con questo ambiente
      },
    };
  },
};

Vitest espone anche builtinEnvironments tramite l'entry point vitest/environments, utile per estendere gli ambienti esistenti. Maggiori informazioni sull'estensione degli ambienti sono disponibili nella nostra guida.

TIP

A partire da Vitest 1.3.0, l'ambiente jsdom espone la variabile globale jsdom, che corrisponde all'istanza corrente di JSDOM. Per farla riconoscere a TypeScript, aggiungi vitest/jsdom al tuo tsconfig.json quando usi questo ambiente:

json

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

environmentOptions

Tipo: Record<'jsdom' | string, unknown>
Predefinito: {}

Queste opzioni vengono passate al metodo setup dell'ambiente corrente (vedi environment). Per impostazione predefinita, è possibile configurare solo le opzioni JSDOM, se utilizzato come ambiente di test.

environmentMatchGlobs

Tipo: [string, EnvironmentName][]
Predefinito: []

Assegna automaticamente l'ambiente di test in base a pattern glob. Viene utilizzata la prima corrispondenza trovata.

Esempio:

import { defineConfig } from 'vitest/config';

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

poolMatchGlobs 0.29.4+

Tipo: [string, 'threads' | 'forks' | 'vmThreads' | 'vmForks' | 'typescript'][]
Predefinito: []

Assegna automaticamente il pool di esecuzione dei test in base a pattern glob. Viene utilizzata la prima corrispondenza trovata.

Esempio:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolMatchGlobs: [
      // tutti i test nella directory "worker-specific" verranno eseguiti all'interno di un worker come se avessi abilitato `--pool=threads` per loro,
      ['**/tests/worker-specific/**', 'threads'],
      // esegui tutti i test nella directory "browser" in un browser reale
      ['**/tests/browser/**', 'browser'],
      // tutti gli altri test verranno eseguiti in base alle opzioni "browser.enabled" e "threads", se non hai specificato altri globs
      // ...
    ],
  },
});

update*

Tipo: boolean
Predefinito: false
CLI: -u, --update, --update=false

Aggiorna i file snapshot. Aggiorna tutti gli snapshot modificati ed elimina quelli obsoleti.

watch*

Tipo: boolean
Predefinito: !process.env.CI
CLI: -w, --watch, --watch=false

Abilita la modalità watch (osservazione).

root

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

Directory radice del progetto.

reporters*

Tipo: Reporter | Reporter[]
Predefinito: 'default'
CLI: --reporter=<name>, --reporter=<name1> --reporter=<name2>

Reporter personalizzati per l'output dei risultati. I reporter possono essere un'istanza di Reporter, una stringa per selezionare i reporter integrati o un percorso a un'implementazione personalizzata (es. './path/to/reporter.ts', '@scope/reporter').

outputFile*

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

Scrive i risultati dei test in un file quando viene specificata anche l'opzione --reporter=json, --reporter=html o --reporter=junit. Fornendo un oggetto invece di una stringa, è possibile definire output individuali quando si utilizzano più reporter.

pool* 1.0.0+

Tipo: 'threads' | 'forks' | 'vmThreads' | 'vmForks'
Predefinito: 'threads'
CLI: --pool=threads

Pool utilizzato per l'esecuzione dei test.

threads*

Abilita il multi-threading utilizzando tinypool (un fork leggero di Piscina). Quando si utilizzano i thread, non è possibile utilizzare API relative ai processi come process.chdir(). Alcune librerie scritte in linguaggi nativi, come Prisma, bcrypt e canvas, presentano problemi quando vengono eseguite in più thread e possono causare segfault. In questi casi, si consiglia di utilizzare il pool forks.

forks*

Simile al pool threads, ma utilizza child_process invece di worker_threads tramite tinypool. La comunicazione tra i test e il processo principale non è veloce come con il pool threads. Le API relative ai processi come process.chdir() sono disponibili nel pool forks.

vmThreads*

Esegue i test utilizzando VM context (all'interno di un ambiente sandbox) in un pool threads.

Questo rende i test più veloci, ma il modulo VM è instabile quando si esegue codice ESM. I test potrebbero causare memory leak (vedi https://github.com/nodejs/node/issues/33439) - per ovviare a questo problema, valuta la possibilità di modificare manualmente il valore di poolOptions.vmThreads.memoryLimit.

WARNING

L'esecuzione di codice in una sandbox presenta vantaggi (test più veloci), ma anche svantaggi.

Le variabili globali dei moduli nativi (come fs, path, ecc.) differiscono dalle variabili globali presenti nel tuo ambiente di test. Di conseguenza, qualsiasi errore generato da questi moduli nativi farà riferimento a un costruttore Error diverso rispetto a quello utilizzato nel tuo codice:

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

L'importazione di moduli ES li memorizza nella cache a tempo indeterminato, il che introduce perdite di memoria se si dispone di molti contesti (file di test). Non esiste un'API in Node.js che cancelli quella cache.
L'accesso alle variabili globali richiede più tempo in un ambiente sandbox.

Si prega di tenere a mente questi problemi quando si utilizza questa opzione. Il team di Vitest non può risolverli.

vmForks*

Simile al pool vmThreads ma utilizza child_process invece di worker_threads tramite tinypool. La comunicazione tra i test e il processo principale non è veloce come con il pool vmThreads. Le API relative ai processi come process.chdir() sono disponibili nel pool vmForks. Si prega di essere consapevoli del fatto che questo pool ha le stesse problematiche elencate in vmThreads.

poolOptions* 1.0.0+

Tipo: Record<'threads' | 'forks' | 'vmThreads' | 'vmForks', {}>
Predefinito: {}

poolOptions.threads

Opzioni per il pool threads.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      threads: {
        // Opzioni relative ai *thread* qui
      },
    },
  },
});

poolOptions.threads.maxThreads*

Tipo: number
Predefinito: CPU disponibili

Il numero massimo di thread. È possibile utilizzare anche la variabile d'ambiente VITEST_MAX_THREADS.

poolOptions.threads.minThreads*

Tipo: number
Predefinito: CPU disponibili

Il numero minimo di thread. È possibile utilizzare anche la variabile d'ambiente VITEST_MIN_THREADS.

poolOptions.threads.singleThread

Tipo: boolean
Predefinito: false

Esegue tutti i test con lo stesso ambiente all'interno di un singolo worker thread. Questo disabilita l'isolamento dei moduli integrati (il codice sorgente o il codice inlined verrà comunque rivalutato per ogni test), ma può migliorare le prestazioni dei test.

WARNING

Anche se questa opzione forza l'esecuzione dei test uno dopo l'altro, è diversa da --runInBand di Jest. Vitest utilizza i worker non solo per eseguire i test in parallelo, ma anche per fornire isolamento. Disabilitando questa opzione, i test verranno eseguiti in sequenza, ma nello stesso contesto globale, quindi è necessario fornire l'isolamento manualmente.

Questo potrebbe causare problemi se ci si affida allo stato globale (come spesso accade nei framework frontend) o se il codice si aspetta che l'ambiente sia definito separatamente per ogni test. Tuttavia, può rappresentare un aumento di velocità per i test che non si basano sullo stato globale o che possono facilmente aggirare questo problema.

poolOptions.threads.useAtomics*

Tipo: boolean
Predefinito: false

Utilizza Atomics per sincronizzare i thread.

Questo può migliorare le prestazioni in alcuni casi, ma potrebbe causare segfault nelle versioni precedenti di Node.

poolOptions.threads.isolate

Tipo: boolean
Predefinito: true

Isola l'ambiente per ogni file di test.

poolOptions.threads.execArgv*

Tipo: string[]
Predefinito: []

Passa argomenti aggiuntivi a node nei thread. Vedi Command-line API | Node.js per maggiori informazioni.

WARNING

Usare con cautela, poiché alcune opzioni potrebbero bloccare il worker, ad es. --prof, --title. Vedi https://github.com/nodejs/node/issues/41103.

poolOptions.forks

Opzioni per il pool forks.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      forks: {
        // Opzioni relative ai *fork* qui
      },
    },
  },
});

poolOptions.forks.maxForks*

Tipo: number
Predefinito: CPU disponibili

Numero massimo di fork.

poolOptions.forks.minForks*

Tipo: number
Predefinito: CPU disponibili

Numero minimo di fork.

poolOptions.forks.isolate

Tipo: boolean
Predefinito: true

Isola l'ambiente per ogni file di test.

poolOptions.forks.singleFork

Tipo: boolean
Predefinito: false

Esegue tutti i test con lo stesso ambiente all'interno di un singolo child process. Questo disabilita l'isolamento dei moduli integrati (il codice sorgente o il codice inlined verrà comunque rivalutato per ogni test), ma può migliorare le prestazioni dei test.

WARNING

Anche se questa opzione forza l'esecuzione dei test uno dopo l'altro, è diversa da --runInBand di Jest. Vitest utilizza i processi figlio non solo per eseguire i test in parallelo, ma anche per fornire isolamento. Disabilitando questa opzione, i test verranno eseguiti in sequenza, ma nello stesso contesto globale, quindi è necessario fornire l'isolamento manualmente.

poolOptions.forks.execArgv*

Tipo: string[]
Predefinito: []

Passa argomenti aggiuntivi al processo node nei processi figli. Vedi Command-line API | Node.js per maggiori informazioni.

WARNING

Usare con cautela, poiché alcune opzioni potrebbero bloccare il worker, ad es. --prof, --title. Vedi https://github.com/nodejs/node/issues/41103.

poolOptions.vmThreads

Opzioni per il pool vmThreads.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      vmThreads: {
        // Opzioni relative ai VM *thread* qui
      },
    },
  },
});

poolOptions.vmThreads.maxThreads*

Tipo: number
Predefinito: CPU disponibili

Il numero massimo di thread. È possibile utilizzare anche la variabile d'ambiente VITEST_MAX_THREADS.

poolOptions.vmThreads.minThreads*

Tipo: number
Predefinito: CPU disponibili

Il numero minimo di thread. È possibile utilizzare anche la variabile d'ambiente VITEST_MIN_THREADS.

poolOptions.vmThreads.memoryLimit*

Tipo: string | number
Predefinito: 1 / CPU Cores

TIP

L'implementazione si basa su workerIdleMemoryLimit di Jest.

Il limite può essere specificato in diversi modi e, qualunque sia il risultato, viene utilizzato Math.floor per trasformarlo in un valore intero:

<= 1 - Si presume che il valore sia una percentuale della memoria di sistema. Quindi, 0.5 imposta il limite di memoria del worker alla metà della memoria totale del sistema.
\> 1 - Si presume che sia un valore di byte fisso. A causa della regola precedente, se si volesse un valore di 1 byte (non so perché), si potrebbe usare 1.1.
Con unità
- 50% - Come sopra, una percentuale della memoria totale del sistema
- 100KB, 65MB, ecc - Con unità per indicare un limite di memoria fisso.
  - K / KB - Kilobyte (x1000)
  - KiB - Kibibyte (x1024)
  - M / MB - Megabyte
  - MiB - Mebibyte
  - G / GB - Gigabyte
  - GiB - Gibibyte

WARNING

Il limite di memoria basato sulla percentuale non funziona sui worker Linux CircleCI (vedi https://github.com/jestjs/jest/issues/11956#issuecomment-1212925677) a causa della segnalazione errata della memoria di sistema.

poolOptions.vmThreads.useAtomics*

Tipo: boolean
Predefinito: false

Utilizza Atomics per sincronizzare i thread.

Questo può migliorare le prestazioni in alcuni casi, ma potrebbe causare segfault nelle versioni precedenti di Node.

poolOptions.vmThreads.execArgv*

Tipo: string[]
Predefinito: []

Passa argomenti aggiuntivi al processo node nel contesto VM. Vedi Command-line API | Node.js per maggiori informazioni.

WARNING

Usare con cautela, poiché alcune opzioni potrebbero bloccare il worker, ad es. --prof, --title. Vedi https://github.com/nodejs/node/issues/41103.

poolOptions.vmForks

Opzioni per il pool vmForks.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      vmForks: {
        // Opzioni relative ai VM *fork* qui
      },
    },
  },
});

poolOptions.vmForks.maxForks*

Tipo: number
Predefinito: CPU disponibili

Il numero massimo di thread. È possibile utilizzare anche la variabile d'ambiente VITEST_MAX_FORKS.

poolOptions.vmForks.minForks*

Tipo: number
Predefinito: CPU disponibili

Il numero minimo di thread. È possibile utilizzare anche la variabile d'ambiente VITEST_MIN_FORKS.

poolOptions.vmForks.memoryLimit*

Tipo: string | number
Predefinito: 1 / CPU Cores

Specifica il limite di memoria per i worker prima che vengano riciclati. Questo valore dipende fortemente dall'ambiente, quindi è consigliabile specificarlo manualmente invece di affidarsi al valore predefinito. Il modo in cui viene calcolato il valore è descritto in poolOptions.vmThreads.memoryLimit

poolOptions.vmForks.execArgv*

Tipo: string[]
Predefinito: []

Passa argomenti aggiuntivi al processo node nel contesto VM. Vedi Command-line API | Node.js per maggiori informazioni.

WARNING

Usare con cautela, poiché alcune opzioni potrebbero bloccare il worker, ad es. --prof, --title. Vedi https://github.com/nodejs/node/issues/41103.

fileParallelism 1.1.0+

Tipo: boolean
Predefinito: true
CLI: --no-file-parallelism, --fileParallelism=false

Specifica se eseguire tutti i file di test in parallelo. Impostando questo valore su false, le opzioni maxWorkers e minWorkers verranno sovrascritte e impostate a 1.

TIP

Questa opzione non influisce sull'esecuzione dei test all'interno dello stesso file. Per eseguirli in parallelo, utilizzare l'opzione concurrent in describe o tramite una configurazione.

maxWorkers 1.1.0+

Tipo: number

Numero massimo di worker utilizzati per l'esecuzione dei test. poolOptions.{threads,vmThreads}.maxThreads/poolOptions.forks.maxForks hanno priorità maggiore.

minWorkers 1.1.0+

Tipo: number

Numero minimo di worker utilizzati per l'esecuzione dei test. poolOptions.{threads,vmThreads}.minThreads/poolOptions.forks.maxForks hanno priorità maggiore.

testTimeout

Tipo: number
Predefinito: 5000
CLI: --test-timeout=5000, --testTimeout=5000

Timeout predefinito per un singolo test, in millisecondi.

hookTimeout

Tipo: number
Predefinito: 10000
CLI: --hook-timeout=10000, --hookTimeout=10000

Timeout predefinito per un hook, in millisecondi.

teardownTimeout*

Tipo: number
Predefinito: 10000
CLI: --teardown-timeout=5000, --teardownTimeout=5000

Timeout predefinito per l'attesa della chiusura di Vitest, in millisecondi.

silent*

Tipo: boolean
Predefinito: false
CLI: --silent, --silent=false

Disabilita l'output nella console durante l'esecuzione dei test.

setupFiles

Tipo: string | string[]

Percorso dei file di setup. Verranno eseguiti prima di ogni file di test.

INFO

La modifica dei file di setup comporterà la riesecuzione di tutti i test.

È possibile utilizzare process.env.VITEST_POOL_ID (stringa simile a un intero) al loro interno per distinguere tra i thread.

TIP

Si noti che se si sta eseguendo --isolate=false, questo file di setup verrà eseguito più volte nello stesso ambito globale. Ciò significa che si sta accedendo allo stesso oggetto globale prima di ogni test, quindi assicurarsi di non ripetere operazioni non necessarie.

Ad esempio, è possibile fare affidamento su una variabile globale:

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

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

// gli hook vengono resettati prima di ogni suite
afterEach(() => {
  cleanup();
});

globalThis.resetBeforeEachTest = true;

globalSetup

Tipo: string | string[]

Percorso dei file di setup globale, relativo alla root del progetto.

Un file di setup globale può esportare funzioni denominate setup e teardown o una funzione default che restituisce una funzione di teardown (esempio).

INFO

È possibile specificare più file globalSetup. Le funzioni setup e teardown vengono eseguite in sequenza, con le funzioni teardown eseguite in ordine inverso.

WARNING

A partire da Vitest 1.0.0-beta, il setup globale viene eseguito solo se è presente almeno un test da eseguire. Ciò significa che il setup globale potrebbe iniziare durante la modalità watch dopo la modifica di un file di test (il file di test attenderà il completamento del setup globale prima di essere eseguito).

Tenere presente che il setup globale viene eseguito in un ambito globale diverso, quindi i test non hanno accesso diretto alle variabili definite qui. Tuttavia, dalla versione 1.0.0 è possibile passare dati serializzabili ai test tramite il metodo provide:

globalSetup.jsglobalSetup.tsexample.test.js

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

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

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

// Puoi anche estendere il tipo `ProvidedContext`
// per avere un accesso type-safe ai metodi `provide/inject`:
declare module 'vitest' {
  export interface ProvidedContext {
    wsPort: number;
  }
}

import { inject } from 'vitest';

inject('wsPort') === 3000;

watchExclude*

Tipo: string[]
Predefinito: ['**/node_modules/**', '**/dist/**']
Obsoleto: utilizzare server.watch.ignored

Pattern Glob di percorsi di file da escludere dal monitoraggio per evitare di attivare la riesecuzione in modalità watch.

forceRerunTriggers*

Tipo: string[]
Predefinito: ['**/package.json/**', '**/vitest.config.*/**', '**/vite.config.*/**']

Pattern Glob di percorsi di file che attivano la riesecuzione dell'intera suite di test. Se utilizzato con l'argomento --changed, esegue l'intera suite di test se il trigger viene trovato nella diff di git.

Utile se si stanno testando chiamate a comandi CLI, perché Vite non può costruire un grafo dei moduli:

test('execute a script', async () => {
  // Vitest non può rieseguire questo test se il contenuto di `dist/index.js` cambia
  await execa('node', ['dist/index.js']);
});

TIP

Assicurarsi che i file non siano esclusi da watchExclude.

coverage*

È possibile utilizzare v8, istanbul o una soluzione di coverage personalizzata per raccogliere i dati di coverage.

È possibile fornire opzioni di coverage alla CLI utilizzando la notazione a punti:

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

WARNING

Se si utilizzano opzioni di coverage con la notazione a punti, assicurarsi di specificare --coverage.enabled. Non fornire una singola opzione --coverage in questo caso.

coverage.provider

Tipo: 'v8' | 'istanbul' | 'custom'
Predefinito: 'v8'
CLI: --coverage.provider=<provider>

Utilizzare provider per selezionare lo strumento di raccolta della coverage.

coverage.enabled

Tipo: boolean
Predefinito: false
Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.enabled, --coverage.enabled=false

Abilita la raccolta della coverage. Può essere sovrascritta utilizzando l'opzione CLI --coverage.

coverage.include

Tipo: string[]
Predefinito: ['**']
Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.include=<path>, --coverage.include=<path1> --coverage.include=<path2>

Elenco di file inclusi nel calcolo della coverage, specificati tramite pattern glob.

coverage.extension

Tipo: string | string[]
Predefinito: ['.js', '.cjs', '.mjs', '.ts', '.mts', '.cts', '.tsx', '.jsx', '.vue', '.svelte', '.marko']
Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.extension=<extension>, --coverage.extension=<extension1> --coverage.extension=<extension2>

coverage.exclude

Tipo: string[]
Predefinito:

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

Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.exclude=<path>, --coverage.exclude=<path1> --coverage.exclude=<path2>

Elenco di file esclusi dal calcolo della coverage, specificati tramite pattern glob.

Questa opzione ha la precedenza su tutte le opzioni predefinite. Estendere le opzioni predefinite quando si aggiungono nuovi pattern da ignorare:

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

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

coverage.all

Tipo: boolean
Predefinito: true (da Vitest 1.0.0)
Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.all, --coverage.all=false

Indica se includere tutti i file, compresi quelli non testati, nel report di coverage.

coverage.clean

Tipo: boolean
Predefinito: true
Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.clean, --coverage.clean=false

Pulisce i risultati della coverage prima di eseguire i test.

coverage.cleanOnRerun

Tipo: boolean
Predefinito: true
Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.cleanOnRerun, --coverage.cleanOnRerun=false

Pulisce il report di coverage durante la riesecuzione in modalità watch.

coverage.reportsDirectory

Tipo: string
Predefinito: './coverage'
Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.reportsDirectory=<path>

WARNING

Vitest eliminerà questa directory prima di eseguire i test se coverage.clean è abilitato (impostazione predefinita).

Directory in cui salvare il report di coverage.

Per visualizzare l'anteprima del report di coverage nell'output dell'HTML reporter, questa opzione deve essere impostata come sottodirectory della directory del report HTML (ad esempio ./html/coverage).

coverage.reporter

Tipo: string | string[] | [string, {}][]
Predefinito: ['text', 'html', 'clover', 'json']
Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.reporter=<reporter>, --coverage.reporter=<reporter1> --coverage.reporter=<reporter2>

Reporter di coverage da utilizzare. Consultare la documentazione di istanbul per un elenco dettagliato di tutti i reporter disponibili. Consultare @types/istanbul-reporter per i dettagli sulle opzioni specifiche di ciascun reporter.

Esistono tre modi per specificare i reporter:

Un singolo reporter: { reporter: 'html' }
Più reporter senza opzioni: { reporter: ['html', 'json'] }

Uno o più reporter con opzioni specifiche:

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

A partire da Vitest 1.2.0, è anche possibile utilizzare reporter di coverage personalizzati. Consultare Guida - Reporter di Coverage Personalizzato per maggiori informazioni.

{
  reporter: [
    // Specifica il reporter utilizzando il nome del pacchetto NPM
    '@vitest/custom-coverage-reporter',
    ['@vitest/custom-coverage-reporter', { someOption: true }],

    // Specifica il reporter utilizzando il percorso locale
    '/absolute/path/to/custom-reporter.cjs',
    ['/absolute/path/to/custom-reporter.cjs', { someOption: true }],
  ];
}

A partire da Vitest 0.31.0, è possibile visualizzare il report di coverage nell'interfaccia utente di Vitest: consultare Vitest UI Coverage per maggiori dettagli.

coverage.reportOnFailure 0.31.2+

Tipo: boolean
Predefinito: false (da Vitest 0.34.0)
Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.reportOnFailure, --coverage.reportOnFailure=false

Genera il report di coverage anche quando i test falliscono.

coverage.allowExternal

Tipo: boolean
Predefinito: false
Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.allowExternal, --coverage.allowExternal=false

Raccoglie la coverage dei file al di fuori della root del progetto.

coverage.skipFull

Tipo: boolean
Predefinito: false
Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.skipFull, --coverage.skipFull=false

Non mostra i file con il 100% di statement, branch e function coverage.

coverage.thresholds

Opzioni per le soglie di coverage.

coverage.thresholds.lines

Tipo: number
Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.thresholds.lines=<number>

Soglia globale per la coverage delle linee. Consultare la documentazione di istanbul per maggiori informazioni.

coverage.thresholds.functions

Tipo: number
Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.thresholds.functions=<number>

Soglia globale per la coverage delle funzioni. Consultare la documentazione di istanbul per maggiori informazioni.

coverage.thresholds.branches

Tipo: number
Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.thresholds.branches=<number>

Soglia globale per la coverage delle diramazioni. Consultare la documentazione di istanbul per maggiori informazioni.

coverage.thresholds.statements

Tipo: number
Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.thresholds.statements=<number>

Soglia globale per la coverage delle istruzioni. Consultare la documentazione di istanbul per maggiori informazioni.

coverage.thresholds.perFile

Tipo: boolean
Predefinito: false
Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.thresholds.perFile, --coverage.thresholds.perFile=false

Verifica le soglie per ogni singolo file.

coverage.thresholds.autoUpdate

Tipo: boolean
Predefinito: false
Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.thresholds.autoUpdate=<boolean>

Aggiorna automaticamente tutti i valori di soglia (lines, functions, branches e statements) nel file di configurazione quando la coverage corrente è superiore alle soglie configurate. Questa opzione aiuta a mantenere aggiornate le soglie quando la coverage viene migliorata.

coverage.thresholds.100

Tipo: boolean
Predefinito: false
Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.thresholds.100, --coverage.thresholds.100=false

Imposta le soglie globali a 100%. Scorciatoia per --coverage.thresholds.lines 100 --coverage.thresholds.functions 100 --coverage.thresholds.branches 100 --coverage.thresholds.statements 100.

coverage.thresholds[glob-pattern]

Tipo: { statements?: number functions?: number branches?: number lines?: number }
Predefinito: undefined
Disponibile per i provider: 'v8' | 'istanbul'

Definisce le soglie per i file che corrispondono al pattern glob specificato.

{
  coverage: {
    thresholds: {
      // Soglie per tutti i file
      functions: 95,
      branches: 70,

      // Soglie per la corrispondenza del pattern glob
      'src/utils/**.ts': {
        statements: 95,
        functions: 90,
        branches: 85,
        lines: 80,
      },

      // I file che corrispondono a questo pattern avranno solo le soglie delle linee impostate.
      // Le soglie globali non sono ereditate.
      '**/math.ts': {
        lines: 100,
      }
    }
  }
}

coverage.ignoreEmptyLines

Tipo: boolean
Predefinito: false
Disponibile per i provider: 'v8'
CLI: --coverage.ignoreEmptyLines=<boolean>

Ignora le righe vuote, i commenti e altro codice non di runtime, ad esempio i tipi Typescript.

Questa opzione funziona solo se il compilatore utilizzato rimuove i commenti e altro codice non di runtime dal codice compilato. Per impostazione predefinita, Vite utilizza ESBuild che rimuove i commenti e i tipi Typescript dai file .ts, .tsx e .jsx.

Se si desidera applicare ESBuild anche ad altri file, definirli nelle opzioni esbuild:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  esbuild: {
    // Transpila tutti i file con ESBuild per rimuovere i commenti dalla code coverage.
    // Richiesto affinché `test.coverage.ignoreEmptyLines` funzioni:
    include: ['**/*.js', '**/*.jsx', '**/*.mjs', '**/*.ts', '**/*.tsx'],
  },
  test: {
    coverage: {
      provider: 'v8',
      ignoreEmptyLines: true,
    },
  },
});

coverage.ignoreClassMethods

Tipo: string[]
Predefinito: []
Disponibile per i provider: 'istanbul'
CLI: --coverage.ignoreClassMethods=<method>

Imposta un array di nomi di metodi di classe da ignorare per la coverage. Consultare la documentazione di istanbul per maggiori informazioni.

coverage.watermarks

Tipo:

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

Predefinito:

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

Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.watermarks.statements=50,80, --coverage.watermarks.branches=50,80

Soglie per le istruzioni, le linee, le diramazioni e le funzioni. Consultare la documentazione di istanbul per maggiori informazioni.

coverage.processingConcurrency

Tipo: boolean
Predefinito: Math.min(20, os.availableParallelism?.() ?? os.cpus().length)
Disponibile per i provider: 'v8' | 'istanbul'
CLI: --coverage.processingConcurrency=<number>

Limite di concorrenza utilizzato durante l'elaborazione dei risultati della coverage.

coverage.customProviderModule

Tipo: string
Disponibile per i provider: 'custom'
CLI: --coverage.customProviderModule=<path or module name>

Specifica il nome del modulo o il percorso del modulo del provider di coverage personalizzato. Consultare Guida - Provider di Coverage Personalizzato per maggiori informazioni.

testNamePattern*

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

Esegue i test i cui nomi completi corrispondono al pattern specificato. Se si aggiunge OnlyRunThis a questa proprietà, verranno ignorati i test che non contengono la stringa OnlyRunThis nel nome.

import { expect, test } from 'vitest';

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

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

open*

Tipo: boolean
Predefinito: !process.env.CI
CLI: --open, --open=false

Apre l'interfaccia utente di Vitest (in fase di sviluppo).

api

Tipo: boolean | number
Predefinito: false
CLI: --api, --api.port, --api.host, --api.strictPort

Avvia un server API sulla porta specificata. Se impostato su true, la porta predefinita è 51204.

browser 0.29.4+

Tipo: { enabled?, name?, provider?, headless?, api?, slowHijackESM? }
Predefinito: { enabled: false, headless: process.env.CI, api: 63315 }
CLI: --browser, --browser=<name>, --browser.name=chrome --browser.headless

Esegue i test di Vitest in un browser. Per impostazione predefinita, utilizza WebdriverIO per l'esecuzione dei test, ma è possibile configurare un altro provider tramite l'opzione browser.provider.

NOTA

Per maggiori informazioni sui test in un browser reale, consultare la pagina della guida.

WARNING

Questa funzionalità è sperimentale. Le modifiche che potrebbero causare problemi di compatibilità non seguiranno necessariamente SemVer. Si consiglia di fissare la versione di Vitest quando si utilizza questa funzionalità.

browser.enabled

Tipo: boolean
Predefinito: false
CLI: --browser, --browser.enabled=false

Abilita l'esecuzione di tutti i test nel browser. Può essere sovrascritto con l'opzione poolMatchGlobs.

browser.name

Tipo: string
CLI: --browser=safari

Specifica il browser in cui eseguire i test. Le opzioni disponibili variano a seconda del provider:

webdriverio: firefox, chrome, edge, safari
playwright: firefox, webkit, chromium
custom: qualsiasi stringa che verrà passata al provider personalizzato.

browser.headless

Tipo: boolean
Predefinito: process.env.CI
CLI: --browser.headless, --browser.headless=false

Esegue il browser in modalità "headless" (senza interfaccia grafica). Abilitato automaticamente se Vitest viene eseguito in un ambiente di Continuous Integration (CI).

browser.isolate

Tipo: boolean
Predefinito: true
CLI: --browser.isolate, --browser.isolate=false

Esegue ogni test in un iframe separato.

browser.fileParallelism 1.3.0+

Tipo: boolean
Predefinito: uguale a fileParallelism
CLI: --browser.fileParallelism=false

Crea tutti gli iframe di test contemporaneamente, consentendo l'esecuzione in parallelo.

Questo impedisce l'utilizzo di API interattive (come clic o eventi del mouse), poiché più iframe sono visibili contemporaneamente. Tuttavia, se i test non dipendono da tali API, l'esecuzione parallela può migliorare significativamente la velocità.

TIP

Se l'isolamento è disabilitato tramite browser.isolate=false, i file di test verranno comunque eseguiti uno dopo l'altro a causa del funzionamento del runner di test.

browser.api

Tipo: number | { port?, strictPort?, host? }
Predefinito: 63315
CLI: --browser.api=63315, --browser.api.port=1234, --browser.api.host=example.com

Configura le opzioni per il server Vite che fornisce il codice al browser. Non influisce sull'opzione test.api.

browser.provider

Tipo: 'webdriverio' | 'playwright' | string
Predefinito: 'webdriverio'
CLI: --browser.provider=playwright

Specifica il provider da utilizzare per l'esecuzione dei test nel browser. Vitest fornisce due provider integrati: webdriverio (predefinito) e playwright. I provider personalizzati devono essere esportati tramite l'esportazione default e devono avere la seguente forma:

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

WARNING

Questa è un'API avanzata destinata agli autori di librerie. Se si desidera semplicemente eseguire test in un browser, utilizzare l'opzione browser.

browser.providerOptions 1.0.0+

Tipo: BrowserProviderOptions

Opzioni che verranno passate al provider durante la chiamata a provider.initialize.

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

TIP

Per una migliore sicurezza dei tipi quando si utilizzano provider integrati, è possibile aggiungere uno di questi tipi (corrispondente al provider utilizzato) al campo compilerOptions.types del file tsconfig.json:

json

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

browser.slowHijackESM 0.31.0+

Tipo: boolean
Predefinito: false

Quando si eseguono test in Node.js, Vitest può utilizzare la propria risoluzione dei moduli per simulare facilmente i moduli con la sintassi vi.mock. Tuttavia, replicare la risoluzione dei moduli ES nel browser è più complesso, quindi è necessario trasformare i file sorgente prima che possano essere utilizzati dal browser.

Questa opzione non influisce sui test eseguiti in Node.js.

Se si utilizza lo spying sui moduli ES con vi.spyOn, è possibile abilitare questa funzionalità sperimentale per consentire lo spying sulle esportazioni dei moduli.

browser.indexScripts 1.6.0+

Tipo: BrowserScript[]
Predefinito: []

Script personalizzati da iniettare nell'HTML dell'indice prima dell'avvio degli iframe di test. Questo documento HTML configura solo gli iframe e non importa direttamente il codice.

Gli script src e content verranno elaborati dai plugin Vite. Lo script deve essere fornito nel seguente formato:

export interface BrowserScript {
  /**
   * Se viene fornito "content" e il tipo è "module", questo sarà il suo identificatore.
   *
   * Se si utilizza TypeScript, è possibile aggiungere l'estensione `.ts` qui, ad esempio.
   * @default `injected-${index}.js`
   */
  id?: string;
  /**
   * Contenuto JavaScript da iniettare. Questa stringa viene elaborata dai plugin Vite se il tipo è "module".
   *
   * È possibile utilizzare `id` per fornire a Vite un suggerimento sull'estensione del file.
   */
  content?: string;
  /**
   * Percorso dello script. Questo valore viene risolto da Vite, quindi può essere un modulo node o un percorso di file.
   */
  src?: string;
  /**
   * Indica se lo script deve essere caricato in modo asincrono.
   */
  async?: boolean;
  /**
   * Tipo di script.
   * @default 'module'
   */
  type?: string;
}

browser.testerScripts 1.6.0+

Tipo: BrowserScript[]
Predefinito: []

Script personalizzati da iniettare nell'HTML del tester prima dell'avvio dell'ambiente di test. Questo è utile per iniettare polyfill necessari per l'implementazione del browser Vitest. Si consiglia di utilizzare setupFiles nella maggior parte dei casi invece di questa opzione.

Gli script src e content verranno elaborati dai plugin Vite.

clearMocks

Tipo: boolean
Predefinito: false

Chiama .mockClear() su tutte le spie prima di ogni test. Questo cancella la cronologia dei mock, ma non ripristina l'implementazione a quella predefinita.

mockReset

Tipo: boolean
Predefinito: false

Chiama .mockReset() su tutte le spie prima di ogni test. Questo cancella la cronologia dei mock e ripristina l'implementazione a una funzione vuota (che restituirà undefined).

restoreMocks

Tipo: boolean
Predefinito: false

Chiama .mockRestore() su tutte le spie prima di ogni test. Questo cancella la cronologia dei mock e ripristina l'implementazione a quella originale.

unstubEnvs 0.26.0+

Tipo: boolean
Predefinito: false

Chiama vi.unstubAllEnvs prima di ogni test.

unstubGlobals 0.26.0+

Tipo: boolean
Predefinito: false

Chiama vi.unstubAllGlobals prima di ogni test.

testTransformMode 0.34.0+

Tipo: { web?, ssr? }

Determina il metodo di trasformazione per tutti i moduli importati all'interno di un test che corrisponde al pattern glob. Per impostazione predefinita, si basa sull'ambiente. Ad esempio, i test con ambiente JSDOM elaboreranno tutti i file con il flag ssr: false e i test con ambiente Node elaboreranno tutti i moduli con ssr: true.

testTransformMode.ssr

Tipo: string[]
Predefinito: []

Utilizza la pipeline di trasformazione SSR (Server-Side Rendering) per tutti i moduli all'interno dei test specificati. I plugin Vite riceveranno il flag ssr: true durante l'elaborazione di tali file.

testTransformMode.web

Tipo: string[]
Predefinito: []

Esegue prima una normale pipeline di trasformazione (destinata al browser), quindi esegue una riscrittura SSR per eseguire il codice in Node.js. I plugin Vite riceveranno il flag ssr: false durante l'elaborazione di tali file.

snapshotFormat*

Tipo: PrettyFormatOptions

Opzioni di formato per lo snapshot testing. Queste opzioni vengono passate a pretty-format.

TIP

Il campo plugins in questo oggetto verrà ignorato.

Se è necessario estendere il serializzatore di snapshot tramite i plugin pretty-format, utilizzare l'API expect.addSnapshotSerializer o l'opzione snapshotSerializers.

snapshotSerializers* 1.3.0+

Tipo: string[]
Predefinito: []

Un elenco di percorsi ai moduli serializzatori di snapshot per lo snapshot testing. Utile per aggiungere serializzatori di snapshot personalizzati. Vedere Serializzatore personalizzato per maggiori informazioni.

resolveSnapshotPath*

Tipo: (testPath: string, snapExtension: string) => string
Predefinito: memorizza i file di snapshot nella directory __snapshots__

Sovrascrive il percorso predefinito dei file di snapshot. Ad esempio, per memorizzare gli snapshot accanto ai file di test:

import { defineConfig } from 'vitest/config';

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

allowOnly

Tipo: boolean
Predefinito: !process.env.CI
CLI: --allowOnly, --allowOnly=false

Consente l'esecuzione di test e suite contrassegnati come 'only'.

dangerouslyIgnoreUnhandledErrors*

Tipo: boolean
Predefinito: false
CLI: --dangerouslyIgnoreUnhandledErrors --dangerouslyIgnoreUnhandledErrors=false

Ignora eventuali errori non gestiti che si verificano.

passWithNoTests*

Tipo: boolean
Predefinito: false
CLI: --passWithNoTests, --passWithNoTests=false

Vitest non segnala un errore se non vengono trovati test.

logHeapUsage

Tipo: boolean
Predefinito: false
CLI: --logHeapUsage, --logHeapUsage=false

Visualizza l'utilizzo della memoria heap dopo ogni test. Utile per il debug di perdite di memoria.

css

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

Configura se il CSS deve essere elaborato. Se escluso, i file CSS verranno sostituiti con stringhe vuote per evitare l'elaborazione successiva. I moduli CSS restituiscono un proxy per non influenzare il runtime.

css.include

Tipo: RegExp | RegExp[]
Predefinito: []

Pattern RegExp per i file che devono restituire CSS effettivo e verranno elaborati dalla pipeline Vite.

TIP

Per elaborare tutti i file CSS, utilizzare /.+/.

css.exclude

Tipo: RegExp | RegExp[]
Predefinito: []

Pattern RegExp per i file che restituiranno un file CSS vuoto.

css.modules

Tipo: { classNameStrategy? }
Predefinito: {}

css.modules.classNameStrategy

Tipo: 'stable' | 'scoped' | 'non-scoped'
Predefinito: 'stable'

Se si decide di elaborare i file CSS, è possibile configurare se i nomi delle classi all'interno dei moduli CSS devono avere un ambito (essere 'scoped'). È possibile scegliere una delle seguenti opzioni:

stable: i nomi delle classi saranno generati come _${name}_${hashedFilename}. Questo significa che la classe generata rimarrà la stessa se il contenuto CSS viene modificato, ma cambierà se il nome del file viene modificato o il file viene spostato in un'altra cartella. Questa impostazione è utile se si utilizza la funzionalità di snapshot.
scoped: i nomi delle classi saranno generati come di consueto, rispettando il metodo css.modules.generateScopeName, se presente, e se l'elaborazione CSS è abilitata. Per impostazione predefinita, il nome del file verrà generato come _${name}_${hash}, dove l'hash include il nome e il contenuto del file.
non-scoped: i nomi delle classi non saranno sottoposti ad hashing.

WARNING

Per impostazione predefinita, Vitest esporta un proxy, bypassando l'elaborazione dei moduli CSS. Se si utilizzano le proprietà CSS nelle classi, è necessario abilitare l'elaborazione CSS utilizzando l'opzione include.

maxConcurrency

Tipo: numero
Valore predefinito: 5
CLI: --max-concurrency=10, --maxConcurrency=10

Il numero massimo di test contrassegnati con test.concurrent che possono essere eseguiti in parallelo.

I test che superano questo limite verranno messi in coda e verranno eseguiti non appena uno slot diventa disponibile.

cache*

Tipo: booleano
CLI: --no-cache, --cache=false

Utilizza questa opzione per disabilitare la funzionalità di cache. Vitest utilizza la cache dei risultati dei test per dare priorità all'esecuzione dei test più lunghi e di quelli falliti.

sequence

Tipo: { sequencer?, shuffle?, seed?, hooks?, setupFiles? }

Opzioni per definire l'ordine di esecuzione dei test.

Puoi specificare le opzioni di sequenza tramite CLI utilizzando la notazione a punti:

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

sequence.sequencer*

Tipo: TestSequencerConstructor
Valore predefinito: BaseSequencer

Una classe personalizzata che definisce i metodi per lo sharding e l'ordinamento dei test. Puoi estendere BaseSequencer da vitest/node se devi ridefinire solo uno dei metodi sort e shard. Entrambi i metodi devono essere presenti.

Lo sharding viene eseguito prima dell'ordinamento e solo se viene fornita l'opzione --shard.

sequence.shuffle

Tipo: boolean | { files?, tests? }
Valore predefinito: false
CLI: --sequence.shuffle, --sequence.shuffle=false

Per eseguire file e test in ordine casuale, puoi abilitare questa opzione o utilizzare l'argomento CLI --sequence.shuffle.

Vitest utilizza solitamente la cache per ordinare i test, dando priorità a quelli a lunga esecuzione per velocizzare l'esecuzione complessiva. Eseguendo file e test in ordine casuale, si perde questo miglioramento delle prestazioni, ma ciò può essere utile per identificare test che dipendono inavvertitamente da un'esecuzione precedente.

sequence.shuffle.files 1.4.0+

Tipo: booleano
Valore predefinito: false
CLI: --sequence.shuffle.files, --sequence.shuffle.files=false

Se desideri randomizzare l'ordine dei file, tieni presente che i test a lunga esecuzione non verranno eseguiti per primi se abiliti questa opzione.

sequence.shuffle.tests 1.4.0+

Tipo: booleano
Valore predefinito: false
CLI: --sequence.shuffle.tests, --sequence.shuffle.tests=false

Se desideri randomizzare l'ordine dei singoli test.

sequence.concurrent 0.32.2+

Tipo: booleano
Valore predefinito: false
CLI: --sequence.concurrent, --sequence.concurrent=false

Per eseguire i test in parallelo, puoi abilitare questa opzione o utilizzare l'argomento CLI --sequence.concurrent.

sequence.seed*

Tipo: numero
Valore predefinito: Date.now()
CLI: --sequence.seed=1000

Imposta il seed per la randomizzazione, se i test vengono eseguiti in ordine casuale.

sequence.hooks

Tipo: 'stack' | 'list' | 'parallel'
Valore predefinito: 'parallel'
CLI: --sequence.hooks=<value>

Permette di modificare l'ordine di esecuzione degli hook.

stack ordinerà gli hook "after" in ordine inverso e gli hook "before" nell'ordine in cui sono stati definiti.
list ordinerà tutti gli hook nell'ordine in cui sono stati definiti.
parallel eseguirà gli hook in un singolo gruppo in parallelo (gli hook nelle suite padre verranno comunque eseguiti prima degli hook della suite corrente).

TIP

Questa opzione non influisce su onTestFinished. Viene sempre chiamato in ordine inverso.

sequence.setupFiles 0.29.3+

Tipo: 'list' | 'parallel'
Valore predefinito: 'parallel'
CLI: --sequence.setupFiles=<value>

Permette di modificare l'ordine di esecuzione dei file di setup.

list eseguirà i file di setup nell'ordine in cui sono stati definiti.
parallel eseguirà i file di setup in parallelo.

typecheck

Opzioni per configurare l'ambiente di test per il typechecking.

typecheck.enabled 1.0.0+

Tipo: booleano
Valore predefinito: false
CLI: --typecheck, --typecheck.enabled

Abilita il typechecking insieme ai tuoi test regolari.

typecheck.only 1.0.0+

Tipo: booleano
Valore predefinito: false
CLI: --typecheck.only

Esegui solo i test di typecheck, quando il typechecking è abilitato. Quando si utilizza la CLI, questa opzione abiliterà automaticamente il typechecking.

typecheck.checker

Tipo: 'tsc' | 'vue-tsc' | stringa
Valore predefinito: tsc

Specifica lo strumento da utilizzare per il type checking. Vitest avvierà un processo con parametri specifici per semplificare l'analisi, a seconda dello strumento scelto. Lo strumento di type checking deve produrre un output nello stesso formato di tsc.

Per utilizzare uno strumento di type checking, è necessario aver installato il pacchetto corrispondente:

tsc richiede il pacchetto typescript
vue-tsc richiede il pacchetto vue-tsc

È anche possibile specificare il percorso di un eseguibile personalizzato o il nome di un comando che produce un output equivalente a tsc --noEmit --pretty false.

typecheck.include

Tipo: stringa[]
Valore predefinito: ['**/*.{test,spec}-d.?(c|m)[jt]s?(x)']

Pattern glob che identifica i file da considerare come file di test per il type checking.

typecheck.exclude

Tipo: stringa[]
Valore predefinito: ['**/node_modules/**', '**/dist/**', '**/cypress/**', '**/.{idea,git,cache,output,temp}/**']

Pattern glob che identifica i file da escludere dal type checking.

typecheck.allowJs

Tipo: booleano
Valore predefinito: false

Verifica i file JS che contengono il commento @ts-check. Se questa opzione è già abilitata nel file tsconfig, questa impostazione non la sovrascriverà.

typecheck.ignoreSourceErrors

Tipo: booleano
Valore predefinito: false

Non interrompere l'esecuzione se Vitest rileva errori al di fuori dei file di test. In questo modo, gli errori non correlati ai test non verranno visualizzati.

Di default, se Vitest rileva un errore nel codice sorgente, l'intera suite di test verrà considerata fallita.

typecheck.tsconfig

Tipo: stringa
Valore predefinito: cerca di trovare il tsconfig.json più vicino

Percorso di un file tsconfig personalizzato, relativo alla directory principale del progetto.

slowTestThreshold*

Tipo: numero
Valore predefinito: 300
CLI: --slow-test-threshold=<number>, --slowTestThreshold=<number>

La soglia in millisecondi oltre la quale un test viene considerato lento e segnalato come tale nei risultati.

chaiConfig 0.30.0+

Tipo: { includeStack?: boolean, showDiff?: boolean, truncateThreshold?: number }
Valore predefinito: { includeStack: false, showDiff: true, truncateThreshold: 40 }

Equivalente alla configurazione di Chai.

chaiConfig.includeStack

Tipo: booleano
Valore predefinito: false

Determina se la stack trace deve essere inclusa nel messaggio di errore di un'asserzione. Il valore predefinito false sopprime la stack trace nel messaggio di errore.

chaiConfig.showDiff

Tipo: booleano
Valore predefinito: true

Determina se il flag showDiff deve essere incluso negli errori di asserzione. Se impostato a false, non verrà mai mostrata la diff; se impostato a true, la diff verrà mostrata solo se l'asserzione lo richiede.

chaiConfig.truncateThreshold

Tipo: numero
Valore predefinito: 40

Definisce la lunghezza massima dei valori attesi e reali nei messaggi di errore delle asserzioni. Se la lunghezza supera questa soglia (ad esempio, in caso di strutture dati di grandi dimensioni), il valore viene troncato e sostituito con qualcosa come [ Array(3) ] o { Object (prop1, prop2) }. Impostare a 0 per disabilitare completamente il troncamento.

Questa opzione di configurazione influisce sul troncamento dei valori nei titoli di test.each e all'interno del messaggio di errore di un'asserzione.

bail 0.31.0+

Tipo: numero
Valore predefinito: 0
CLI: --bail=<value>

Interrompe l'esecuzione dei test dopo che il numero specificato di test è fallito.

Di default, Vitest esegue tutti i test anche se alcuni falliscono. Questo comportamento potrebbe non essere desiderabile in ambienti CI, dove si desidera interrompere l'esecuzione al primo errore per velocizzare il processo. L'opzione bail permette di interrompere l'esecuzione dopo un certo numero di fallimenti.

retry 0.32.3+

Tipo: numero
Valore predefinito: 0
CLI: --retry=<value>

Specifica il numero di tentativi da effettuare in caso di fallimento di un test.

onConsoleLog*

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

Gestore personalizzato per la funzione console.log durante i test. Se restituisci false, Vitest non stamperà il log nella console.

Può essere utile per filtrare i log da librerie di terze parti.

import { defineConfig } from 'vitest/config';

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

onStackTrace* 1.0.0+

Tipo: (error: Error, frame: ParsedStack) => boolean | void

Applica una funzione di filtro a ciascun frame di ogni stack trace durante la gestione degli errori. Il primo argomento, error, è un oggetto con le stesse proprietà di un Error standard, ma non è un'istanza effettiva.

Può essere utile per filtrare i frame di stack trace da librerie di terze parti.

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

export default defineConfig({
  test: {
    onStackTrace(error: Error, { file }: ParsedStack): boolean | void {
      // Se abbiamo riscontrato un ReferenceError, mostra l'intera stack.
      if (error.name === 'ReferenceError') return;

      // Rifiuta tutti i frame da librerie di terze parti.
      if (file.includes('node_modules')) return false;
    },
  },
});

diff 0.34.5+

Tipo: stringa
CLI: --diff=<value>

Percorso di un file di configurazione diff che verrà utilizzato per personalizzare l'interfaccia di visualizzazione delle differenze. Utile se desideri personalizzare la visualizzazione diff.

vitest.diff.tsvitest.config.js

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

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

import { defineConfig } from 'vitest/config';

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

diff.truncateThreshold

Tipo: numero
Valore predefinito: 0

La lunghezza massima della diff da visualizzare. Le diff che superano questa lunghezza verranno troncate. Il troncamento è disabilitato di default (valore 0).

diff.truncateAnnotation

Tipo: stringa
Valore predefinito: '... Diff result is truncated'

Testo che viene aggiunto alla fine della diff se questa è stata troncata.

diff.truncateAnnotationColor

Tipo: DiffOptionsColor = (arg: string) => stringa
Valore predefinito: noColor = (string: string): string => string

Colore del testo dell'annotazione di troncamento. Di default, l'annotazione viene visualizzata senza colore.

fakeTimers

Tipo: FakeTimerInstallOpts

Opzioni che Vitest passerà a @sinon/fake-timers quando si invoca vi.useFakeTimers().

fakeTimers.now

Tipo: numero | Data
Valore predefinito: Date.now()

Imposta l'epoca Unix iniziale per i fake timers.

fakeTimers.toFake

Tipo: ('setTimeout' | 'clearTimeout' | 'setImmediate' | 'clearImmediate' | 'setInterval' | 'clearInterval' | 'Date' | 'nextTick' | 'hrtime' | 'requestAnimationFrame' | 'cancelAnimationFrame' | 'requestIdleCallback' | 'cancelIdleCallback' | 'performance' | 'queueMicrotask')[ ]
Valore predefinito: ['setTimeout', 'clearTimeout', 'setImmediate', 'clearImmediate', 'setInterval', 'clearInterval', 'Date']

Un array contenente i nomi dei metodi globali e delle API da simulare.

Per simulare solo setTimeout() e nextTick(), specifica questa proprietà come ['setTimeout', 'nextTick'].

La simulazione di nextTick non è supportata quando Vitest viene eseguito all'interno di node:child_process con l'opzione --pool=forks. NodeJS utilizza internamente process.nextTick in node:child_process, causando un blocco quando viene simulato. La simulazione di nextTick è supportata quando Vitest viene eseguito con l'opzione --pool=threads.

fakeTimers.loopLimit

Tipo: numero
Valore predefinito: 10_000

Il numero massimo di timer che verranno eseguiti quando si chiama vi.runAllTimers().

fakeTimers.shouldAdvanceTime

Tipo: booleano
Valore predefinito: false

Indica a @sinonjs/fake-timers di incrementare automaticamente il tempo simulato in base alle variazioni del tempo reale del sistema (ad esempio, il tempo simulato aumenterà di 20 ms per ogni 20 ms di variazione nel tempo reale).

fakeTimers.advanceTimeDelta

Tipo: numero
Valore predefinito: 20

Valido solo se utilizzato con shouldAdvanceTime: true. Incrementa il tempo simulato di advanceTimeDelta ms per ogni variazione di advanceTimeDelta ms nel tempo reale.

fakeTimers.shouldClearNativeTimers

Tipo: booleano
Valore predefinito: false

Indica ai fake timers di cancellare i timer "nativi" (ovvero, non simulati) delegando la cancellazione ai rispettivi gestori. Questi timer non vengono cancellati di default, il che può portare a comportamenti inattesi se esistevano timer prima dell'inizio della simulazione.

workspace* 1.1.0+

Tipo: stringa
CLI: --workspace=./file.js
Valore predefinito: vitest.{workspace,projects}.{js,ts,json} vicino al file di configurazione o alla root

Percorso del file di configurazione del workspace, relativo alla directory root.

isolate 1.1.0+

Tipo: booleano
Valore predefinito: true
CLI: --no-isolate, --isolate=false

Esegui i test in un ambiente isolato. Questa opzione non ha effetto sui pool vmThreads e vmForks.

La disabilitazione di questa opzione potrebbe migliorare le prestazioni se il tuo codice non si basa su effetti collaterali (il che è solitamente vero per i progetti con ambiente node).

TIP

Puoi disabilitare l'isolamento per pool specifici utilizzando la proprietà poolOptions.

includeTaskLocation 1.4.0+

Tipo: booleano
Valore predefinito: false

Indica se la proprietà location deve essere inclusa quando l'API Vitest riceve i task nei reporter. L'inclusione di questa proprietà può causare una leggera regressione delle prestazioni se si hanno molti test.

La proprietà location contiene i valori column e line che indicano la posizione della dichiarazione test o describe nel file originale.

TIP

Questa opzione non ha effetto se non utilizzi codice personalizzato che si basa su questo.

snapshotEnvironment 1.6.0+

Tipo: stringa

Percorso di un'implementazione personalizzata dell'ambiente snapshot. Questa opzione è utile se i test vengono eseguiti in un ambiente che non supporta le API Node.js. Non ha alcun effetto se si utilizza un browser runner.

Questo oggetto dovrebbe avere la forma di SnapshotEnvironment e viene utilizzato per risolvere e leggere/scrivere file snapshot:

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

Puoi estendere VitestSnapshotEnvironment predefinito dal punto di ingresso vitest/snapshot se devi sovrascrivere solo una parte dell'API.

WARNING

Questa è un'opzione di basso livello e dovrebbe essere utilizzata solo per casi avanzati in cui non hai accesso alle API Node.js predefinite.

Se hai solo bisogno di configurare la funzionalità snapshot, utilizza le opzioni snapshotFormat o resolveSnapshotPath.

Configurazione di Vitest ​

include ​

exclude ​

includeSource ​

server 0.34.0+ ​

server.sourcemap ​

server.debug ​

server.debug.dumpModules ​

server.debug.loadDumppedModules ​

server.deps ​

server.deps.external ​

server.deps.inline ​

server.deps.fallbackCJS ​

server.deps.cacheDir ​

deps ​

deps.optimizer 0.34.0+ ​

deps.optimizer.{mode}.enabled ​

deps.web 0.34.2+ ​

deps.web.transformAssets ​

deps.web.transformCss ​

deps.web.transformGlobPattern ​

deps.interopDefault ​

deps.moduleDirectories ​

runner ​

benchmark ​

benchmark.include ​

benchmark.exclude ​

benchmark.includeSource ​

benchmark.reporters ​

benchmark.outputFile ​

benchmark.outputJson 1.6.0+ ​

benchmark.compare 1.6.0+ ​

alias ​

globals ​

environment ​

environmentOptions ​

environmentMatchGlobs ​

poolMatchGlobs 0.29.4+ ​

update* ​

watch* ​

root ​

reporters* ​

outputFile* ​

pool* 1.0.0+ ​

threads* ​

forks* ​

vmThreads* ​

vmForks* ​

poolOptions* 1.0.0+ ​

poolOptions.threads ​

poolOptions.threads.maxThreads* ​

poolOptions.threads.minThreads* ​

poolOptions.threads.singleThread ​

poolOptions.threads.useAtomics* ​

poolOptions.threads.isolate ​

poolOptions.threads.execArgv* ​

poolOptions.forks ​

poolOptions.forks.maxForks* ​

poolOptions.forks.minForks* ​

poolOptions.forks.isolate ​

poolOptions.forks.singleFork ​

poolOptions.forks.execArgv* ​

poolOptions.vmThreads ​

poolOptions.vmThreads.maxThreads* ​

poolOptions.vmThreads.minThreads* ​

poolOptions.vmThreads.memoryLimit* ​

poolOptions.vmThreads.useAtomics* ​

poolOptions.vmThreads.execArgv* ​

poolOptions.vmForks ​

poolOptions.vmForks.maxForks* ​

poolOptions.vmForks.minForks* ​

poolOptions.vmForks.memoryLimit* ​

poolOptions.vmForks.execArgv* ​

fileParallelism 1.1.0+ ​

maxWorkers 1.1.0+ ​

minWorkers 1.1.0+ ​

testTimeout ​

hookTimeout ​

teardownTimeout* ​

silent* ​

Configurazione di Vitest

include

exclude

includeSource

server 0.34.0+

server.sourcemap

server.debug

server.debug.dumpModules

server.debug.loadDumppedModules

server.deps

server.deps.external

server.deps.inline

server.deps.fallbackCJS

server.deps.cacheDir

deps

deps.optimizer 0.34.0+

deps.optimizer.{mode}.enabled

deps.web 0.34.2+

deps.web.transformAssets

deps.web.transformCss

deps.web.transformGlobPattern

deps.interopDefault

deps.moduleDirectories

runner

benchmark

benchmark.include

benchmark.exclude

benchmark.includeSource

benchmark.reporters

benchmark.outputFile

benchmark.outputJson 1.6.0+

benchmark.compare 1.6.0+

alias

globals

environment

environmentOptions

environmentMatchGlobs

poolMatchGlobs 0.29.4+

update*

watch*

root

reporters*

outputFile*

pool* 1.0.0+

threads*

forks*

vmThreads*

vmForks*

poolOptions* 1.0.0+

poolOptions.threads

poolOptions.threads.maxThreads*

poolOptions.threads.minThreads*

poolOptions.threads.singleThread

poolOptions.threads.useAtomics*

poolOptions.threads.isolate

poolOptions.threads.execArgv*

poolOptions.forks

poolOptions.forks.maxForks*

poolOptions.forks.minForks*

poolOptions.forks.isolate

poolOptions.forks.singleFork

poolOptions.forks.execArgv*

poolOptions.vmThreads

poolOptions.vmThreads.maxThreads*

poolOptions.vmThreads.minThreads*

poolOptions.vmThreads.memoryLimit*

poolOptions.vmThreads.useAtomics*

poolOptions.vmThreads.execArgv*

poolOptions.vmForks

poolOptions.vmForks.maxForks*

poolOptions.vmForks.minForks*

poolOptions.vmForks.memoryLimit*

poolOptions.vmForks.execArgv*

fileParallelism 1.1.0+

maxWorkers 1.1.0+

minWorkers 1.1.0+

testTimeout

hookTimeout

teardownTimeout*

silent*