Configurazione di Vitest

Configurazione

vitest leggerà il file vite.config.ts nella directory principale del progetto, se presente, per utilizzare gli stessi plugin e la stessa configurazione dell'app Vite. Se si desidera una configurazione diversa per i test o se l'app principale non si basa specificamente su Vite, è possibile:

Creare un file vitest.config.ts, che avrà la priorità più alta e sovrascriverà la configurazione di vite.config.ts.
Passare l'opzione --config alla CLI, ad esempio vitest --config ./path/to/vitest.config.ts.
Utilizzare process.env.VITEST o la proprietà mode su defineConfig (che sarà impostata su test o benchmark se non diversamente specificato) per applicare condizionatamente una configurazione diversa in vite.config.ts.

Per configurare vitest stesso, aggiungere la proprietà test alla configurazione Vite. Se si importa defineConfig da vite, è necessario aggiungere un riferimento ai tipi di Vitest utilizzando un comando triple slash nella parte superiore del file di configurazione.

Se si utilizza defineConfig da vite, seguire questo esempio:

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

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

Se si utilizza defineConfig da vitest/config, seguire questo esempio:

import { defineConfig } from 'vitest/config';

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

È possibile estendere le opzioni standard di Vitest, se necessario:

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

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

Quando si utilizza un file vitest.config.js separato, è anche possibile estendere le opzioni di Vite da un altro file di configurazione, se necessario:

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

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

WARNING

La funzione helper mergeConfig è disponibile in Vitest a partire dalla versione 0.30.0. Se si utilizza una versione precedente, è possibile importarla direttamente da vite.

Se la configurazione di Vite è definita come una funzione, è possibile definirla nel modo seguente:

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

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

Opzioni

TIP

Oltre alle opzioni elencate di seguito, è possibile utilizzare qualsiasi opzione di configurazione di Vite. Ad esempio, define per definire variabili globali o resolve.alias per definire alias.

TIP

Tutte le opzioni di configurazione che non sono supportate all'interno di una configurazione di progetto workspace sono contrassegnate con *.

include

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

File da includere nell'esecuzione dei test, utilizzando pattern glob.

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

File da escludere dall'esecuzione dei test, utilizzando pattern glob.

includeSource

Tipo: string[]
Predefinito: []

Pattern glob per i file di test in-source.

Quando definito, Vitest eseguirà tutti i file corrispondenti con import.meta.vitest al loro interno.

server

Tipo: { sourcemap?, deps?, ... }
Versione: Da Vitest 0.34.0

Opzioni per il server Vite-Node.

server.sourcemap

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

Inietta 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 presenti. Utile per il debug modificando il risultato salvato nel filesystem.

server.deps

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

Gestione della risoluzione delle dipendenze.

server.deps.external

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

Esternalizzare significa che Vite passerà il pacchetto direttamente a Node.js. Le dipendenze esternalizzate non verranno elaborate dai trasformatori e dai resolver di Vite, quindi non supporteranno l'HMR 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 si utilizza un'espressione regolare, Vitest la applica al percorso del file, non al nome del pacchetto.

server.deps.inline

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

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

Se impostato su true, ogni dipendenza sarà in linea. Tutte le dipendenze specificate in ssr.noExternal saranno in linea 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 ha un file ESM non corretto.

Ciò potrebbe causare potenziali incongruenze se un pacchetto ha una logica differente in modalità ESM e CJS.

server.deps.cacheDir

Tipo: string
Predefinito: 'node_modules/.vite'

Directory per salvare i file della cache.

deps

Tipo: { optimizer?, registerNodeLoader?, ... }

Gestione della risoluzione delle dipendenze.

deps.optimizer

Tipo: { ssr?, web? }
Versione: Da Vitest 0.34.0
Vedi anche: Opzioni di ottimizzazione delle dipendenze

Abilita l'ottimizzazione delle dipendenze; questo può migliorare le prestazioni se si hanno molti test. Prima di Vitest 0.34.0, era denominata deps.experimentalOptimizer.

Quando Vitest rileva una libreria esterna elencata in include, la raggrupperà in un singolo file usando esbuild e la importerà come un modulo completo. Questo è vantaggioso per diversi motivi:

Importare pacchetti con molte dipendenze è dispendioso in termini di risorse. 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.

Si noti che solo i pacchetti nell'opzione deps.optimizer?.[mode].include vengono raggruppati (alcuni plugin lo popolano automaticamente, come Svelte). È possibile 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 si ridefinisce l'opzione include/exclude in deps.optimizer, verrà esteso optimizeDeps quando si eseguono i test. Vitest rimuove automaticamente le stesse opzioni da include, se sono elencate in exclude.

TIP

Non sarà possibile modificare il codice in node_modules per il debug, poiché il codice effettivo si trova nella directory cacheDir o test.cache.dir. Per eseguire il debug con istruzioni console.log, modificare direttamente il codice o forzare un nuovo bundling con l'opzione deps.optimizer?.[mode].force.

deps.optimizer.{mode}.enabled

Tipo: boolean
Predefinito: true se si utilizza >= Vite 4.3.2, false altrimenti

Abilita l'ottimizzazione delle dipendenze.

WARNING

Questa opzione funziona solo con Vite 4.3.2 e versioni successive.

deps.web

Tipo: { transformAssets?, ... }
Versione: Da Vite 0.34.2

Opzioni 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 influiscono anche sui file in server.deps.external.

deps.web.transformAssets

Tipo: boolean
Predefinito: true

Vitest elaborerà i file di risorse (ad esempio, .png, .svg, .jpg) e li risolverà come farebbe Vite nel browser.

Questo modulo avrà un'esportazione predefinita corrispondente al percorso della risorsa, a meno che non venga specificata una query.

WARNING

Al momento, questa opzione funziona solo con il pool experimentalVmThreads.

deps.web.transformCss

Tipo: boolean
Predefinito: true

Vitest elaborerà i file CSS (ad esempio, .css, .scss, .sass) e li risolverà come farebbe Vite nel browser.

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

WARNING

Al momento, questa opzione funziona solo con il pool experimentalVmThreads.

deps.web.transformGlobPattern

Tipo: RegExp | RegExp[]
Predefinito: []

Pattern RegExp per identificare 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 il pool experimentalVmThreads.

deps.registerNodeLoader*

Tipo: boolean
Predefinito: false

Utilizza il Node loader sperimentale per risolvere le importazioni nei file esternalizzati, usando l'algoritmo di risoluzione di Vite.

Se disabilitato, alias e <plugin>.resolveId non influenzeranno le importazioni nei pacchetti esternalizzati (per impostazione predefinita, node_modules).

deps.interopDefault

Tipo: boolean
Predefinito: true

Interpreta il valore predefinito dei moduli CJS come esportazioni denominate. Alcune dipendenze includono solo moduli CJS e non utilizzano esportazioni denominate che Node.js può analizzare staticamente quando un pacchetto viene importato con la sintassi import invece di 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, è probabile che si verifichi questo errore durante l'esecuzione dei test se questa funzionalità è disabilitata:

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

Per impostazione predefinita, Vitest presuppone che si stia utilizzando un bundler per risolvere questo problema e non genererà errori; tuttavia, è possibile disabilitare questo comportamento manualmente se il codice non viene elaborato.

deps.moduleDirectories

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

Un elenco di directory da considerare come directory dei moduli. Questa opzione di configurazione influisce sul comportamento di vi.mock: quando non viene fornita alcuna factory e il percorso di ciò che si sta simulando 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.

L'impostazione di questa opzione sovrascriverà il valore predefinito; se si desidera comunque cercare i pacchetti in node_modules, includerlo insieme alle altre opzioni:

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 di un runner di test personalizzato. Questa è una funzionalità avanzata e dovrebbe essere utilizzata con runner di librerie personalizzati. Ulteriori informazioni sono disponibili 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 i file di test benchmark.

benchmark.exclude

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

Pattern glob per escludere i file di test benchmark.

benchmark.includeSource

Tipo: string[]
Predefinito: []

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

Quando definito, Vitest eseguirà tutti i file corrispondenti con import.meta.vitest al loro interno.

benchmark.reporters

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

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

benchmark.outputFile

Tipo: string | Record<string, string>

Salva i risultati del benchmark in un file quando viene specificata l'opzione --reporter=json. Fornendo un oggetto invece di una stringa, è possibile definire output individuali quando si utilizzano più reporter.

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

alias

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

Definisce alias personalizzati durante l'esecuzione dei test. Verranno uniti agli alias definiti in resolve.alias.

globals

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

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

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

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

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

json

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

Se si sta già utilizzando unplugin-auto-import nel progetto, è possibile utilizzarlo direttamente per importare automaticamente queste API.

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

export default defineConfig({
  plugins: [
    AutoImport({
      imports: ['vitest'],
      dts: true, // genera la dichiarazione di tipo TypeScript
    }),
  ],
});

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, come jsdom o happy-dom. Per lo sviluppo di funzioni edge, è disponibile l'ambiente edge-runtime.

È possibile specificare un ambiente diverso per tutti i test in un singolo file tramite un docblock @vitest-environment o un commento all'inizio del file:

Formato Docblock:

/**
 * @vitest-environment jsdom
 */

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

Formato commento:

// @vitest-environment happy-dom

test('use happy-dom in this test file', () => {
  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 si esegue Vitest con il flag --threads=false, i test verranno eseguiti nel seguente ordine: node, jsdom, happy-dom, edge-runtime, custom environments. Questo significa che i test con lo stesso ambiente vengono raggruppati, ma eseguiti in sequenza.

A partire dalla versione 0.23.0, è possibile definire un ambiente personalizzato. Quando si utilizza un ambiente non integrato, Vitest tenterà di caricare il pacchetto vitest-environment-${name}. Questo pacchetto deve esportare un oggetto con la struttura Environment:

import type { Environment } from 'vitest';

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

Vitest espone anche builtinEnvironments tramite l'entry vitest/environments, nel caso si voglia estenderlo. Maggiori informazioni sull'estensione degli ambienti sono disponibili nella nostra guida.

environmentOptions

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

Queste opzioni vengono passate al metodo setup dell'environment corrente. Di default, è 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. Verrà 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

Tipo: [string, 'threads' | 'child_process' | 'experimentalVmThreads'][]
Predefinito: []
Versione: Da Vitest 0.29.4

Assegna automaticamente il pool di esecuzione dei test in base a pattern glob. Verrà 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 `--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 di snapshot. Aggiornerà tutti gli snapshot modificati ed eliminerà quelli obsoleti.

watch*

Tipo: boolean
Predefinito: true
CLI: -w, --watch, --watch=false

Abilita la modalità watch.

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 test. I reporter possono essere un'istanza di Reporter o una stringa per selezionare i reporter integrati:

'default' - Raggruppa le suite quando vengono superate.
'basic' - Fornisce un reporter simile a quello predefinito per l'integrazione continua.
'verbose' - Mantiene l'intero albero delle attività visibile.
'dot' - Mostra ogni attività come un singolo punto.
'junit' - Reporter XML JUnit (è possibile configurare il nome del tag testsuites con la variabile d'ambiente VITEST_JUNIT_SUITE_NAME e la proprietà del tag classname con VITEST_JUNIT_CLASSNAME).
'json' - Fornisce un semplice riepilogo JSON.
'html' - Genera un report HTML basato su @vitest/ui.
'hanging-process' - Mostra un elenco di processi in attesa, se Vitest non riesce a terminare il processo in modo sicuro. Questa operazione potrebbe essere pesante, quindi abilitarla solo se Vitest non riesce costantemente a terminare il processo.
Percorso di un reporter personalizzato (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.

experimentalVmThreads

Tipo: boolean
CLI: --experimentalVmThreads, --experimental-vm-threads
Versione: Da Vitest 0.34.0

Esegue i test utilizzando il contesto VM (all'interno di un ambiente sandbox) in un pool di worker.

Questo velocizza i test, ma il modulo VM è instabile quando si esegue codice ESM. I test potrebbero presentare memory leak; per evitarlo, si consiglia di modificare manualmente il valore di experimentalVmWorkerMemoryLimit.

WARNING

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

Le variabili globali all'interno dei moduli nativi, come (fs, path, ecc.), differiscono dalle variabili globali presenti nell'ambiente di test. Di conseguenza, qualsiasi errore generato da questi moduli nativi farà riferimento a un costruttore Error diverso rispetto a quello utilizzato nel 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 essere consapevoli di questi problemi quando si utilizza questa opzione. Il team di Vitest non può risolvere nessuno dei problemi dal nostro lato.

experimentalVmWorkerMemoryLimit

Tipo: string | number
CLI: --experimentalVmWorkerMemoryLimit, --experimental-vm-worker-memory-limit
Predefinito: 1 / Numero di core della CPU
Versione: Da Vitest 0.34.0

Specifica il limite di memoria per i worker prima che vengano riciclati. Questo valore dipende molto dall'ambiente, quindi è consigliabile specificarlo manualmente invece di fare affidamento sul valore predefinito.

Questa opzione influisce solo sui worker che eseguono i test nel contesto VM.

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 impostare un valore di 1 byte (anche se non è una pratica comune), 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 a causa della segnalazione errata della memoria di sistema.

threads

Tipo: boolean
Predefinito: true
CLI: --threads, --threads=false

Abilita il multi-threading utilizzando tinypool (un fork leggero di Piscina). Prima di Vitest 0.29.0, Vitest eseguiva i test all'interno del thread worker anche se questa opzione era disabilitata. Dalla versione 0.29.0, se questa opzione è disabilitata, Vitest utilizza child_process per generare un processo per eseguire i test all'interno, il che significa che è possibile utilizzare process.chdir e altre API che non erano disponibili all'interno dei worker. Se si desidera tornare al comportamento precedente, utilizzare invece l'opzione --single-thread.

La disabilitazione di questa opzione fa sì che tutti i test vengano eseguiti all'interno di più processi figlio.

singleThread

Tipo: boolean
Predefinito: false
Versione: Da Vitest 0.29.0

Esegue tutti i test con lo stesso ambiente all'interno di un singolo thread worker. 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. Prima di Vitest 0.29.0 questo era equivalente all'utilizzo di --no-threads.

WARNING

Anche se questa opzione forzerà l'esecuzione dei test uno dopo l'altro, questa opzione è 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 diversi problemi se si fa affidamento sullo stato globale (come spesso accade nei framework frontend) o se il codice richiede che l'ambiente sia definito separatamente per ogni test. Tuttavia, può portare a un aumento della velocità dei test (fino a 3 volte più velocemente) per quei test che non dipendono dallo stato globale o che possono facilmente aggirarlo.

maxThreads*

Tipo: number
Predefinito: CPU disponibili

Numero massimo di thread. È anche possibile usare la variabile d'ambiente VITEST_MAX_THREADS.

minThreads*

Tipo: number
Predefinito: CPU disponibili

Numero minimo di thread. È anche possibile usare la variabile d'ambiente VITEST_MIN_THREADS.

useAtomics*

Tipo: boolean
Predefinito: false
Versione: Da Vitest 0.28.3

Utilizza Atomics per sincronizzare i thread.

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

testTimeout

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

Timeout predefinito per un test, in millisecondi.

hookTimeout

Tipo: number
Predefinito: 10000

Timeout predefinito per un hook, in millisecondi.

teardownTimeout*

Tipo: number
Predefinito: 10000

Timeout predefinito per attendere la chiusura quando Vitest si spegne, in millisecondi.

silent*

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

Disabilita l'output su console dei test.

setupFiles

Tipo: string | string[]

Percorso dei file di configurazione iniziale. Verranno eseguiti prima di ogni file di test.

INFO

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

È possibile usare process.env.VITEST_POOL_ID (stringa simile a un intero) all'interno per distinguere tra i thread (sarà sempre '1', se eseguito con threads: false).

TIP

Nota che se si sta eseguendo --threads=false, questo file di setup verrà eseguito nello stesso scope globale più volte. Questo significa che si sta accedendo allo stesso oggetto globale prima di ogni test, quindi è importante 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;
}

// hooks are reset before each suite
afterEach(() => {
  cleanup();
});

globalThis.resetBeforeEachTest = true;

globalSetup

Tipo: string | string[]

Percorso dei file di setup globali, 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

Sono possibili più file globalSetup. setup e teardown vengono eseguiti in sequenza, con teardown in ordine inverso.

WARNING

È importante notare che il setup globale viene eseguito in un contesto globale diverso, quindi i test non avranno accesso alle variabili definite in questa fase.

watchExclude*

Tipo: string[]
Predefinito: ['**/node_modules/**', '**/dist/**']

Pattern glob dei percorsi dei file da ignorare per l'attivazione della riesecuzione in modalità watch.

forceRerunTriggers*

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

Pattern glob dei percorsi dei file che attivano la riesecuzione dell'intera suite. Se utilizzato con l'argomento --changed, l'intera suite di test verrà eseguita se il trigger viene trovato nella diff di Git.

Utile se si sta testando la chiamata di comandi CLI, perché Vite non può costruire un grafo di moduli:

test('execute a script', async () => {
  // Vitest cannot rerun this test, if content of `dist/index.js` changes
  await execa('node', ['dist/index.js']);
});

TIP

Assicurarsi che i file non siano esclusi da watchExclude.

isolate

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

Isola l'ambiente per ogni file di test. Questa opzione non è efficace se si disabilita --threads.

Questa opzione non influisce su experimentalVmThreads.

copertura*

È possibile utilizzare v8, istanbul o una soluzione di copertura personalizzata per raccogliere la code coverage.

Le opzioni di copertura possono essere fornite alla CLI utilizzando la notazione a punti:

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

WARNING

Se si utilizzano le opzioni di copertura 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>

Seleziona lo strumento per la raccolta della copertura utilizzando provider.

coverage.enabled

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

Abilita la raccolta della copertura. Può essere sovrascritta con 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 dei file da includere nella copertura, specificati come pattern glob.

coverage.extension

Tipo: string | string[]
Predefinito: ['.js', '.cjs', '.mjs', '.ts', '.mts', '.cts', '.tsx', '.jsx', '.vue', '.svelte']
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}.?(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 dei file da escludere dalla copertura, specificati come pattern glob.

coverage.all

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

Indica se includere tutti i file nel report, anche quelli non testati.

coverage.clean

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

Elimina i risultati della copertura precedenti prima di eseguire i test.

coverage.cleanOnRerun

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

Elimina il report di copertura quando i test vengono rieseguiti in modalità watch.

coverage.reportsDirectory

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

Directory in cui salvare il report di copertura.

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 copertura da utilizzare. Consultare la documentazione di istanbul per un elenco dettagliato di tutti i reporter. Consultare @types/istanbul-reporter per i dettagli sulle opzioni specifiche del reporter.

Il reporter può essere specificato in tre modi diversi:

Un singolo reporter: { reporter: 'html' }
Reporter multipli senza opzioni: { reporter: ['html', 'json'] }

Uno o più reporter con opzioni:

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

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

coverage.reportOnFailure

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

Genera il report di copertura anche se i test falliscono.

coverage.allowExternal

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

Raccoglie la copertura dei file esterni alla directory 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 una copertura del 100% per statement, branch e function.

coverage.perFile

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

Verifica le soglie per ogni file. Vedere lines, functions, branches e statements per le soglie effettive.

coverage.thresholdAutoUpdate

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

Aggiorna i valori di soglia lines, functions, branches e statements nel file di configurazione quando la copertura corrente è superiore alle soglie configurate. Questa opzione consente di mantenere le soglie quando la copertura viene migliorata.

coverage.lines

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

Soglia per le linee di codice. Vedere la documentazione di istanbul per maggiori informazioni.

coverage.functions

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

Soglia per le funzioni. Vedere la documentazione di istanbul per maggiori informazioni.

coverage.branches

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

Soglia per i branch. Vedere la documentazione di istanbul per maggiori informazioni.

coverage.statements

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

Soglia per gli statement. Vedere la documentazione di istanbul per maggiori informazioni.

coverage.100

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

Alias per impostare --coverage.lines 100 --coverage.functions 100 --coverage.branches 100 --coverage.statements 100.

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 copertura. Vedere 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'

Watermark per statements, linee, branch e funzioni. Vedere la documentazione di istanbul per maggiori informazioni.

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 copertura personalizzato. Vedere Guida - Custom Coverage Provider 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à, i test che non contengono la parola OnlyRunThis nel nome verranno saltati.

import { expect, test } from 'vitest';

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

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

open*

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

Apre l'interfaccia utente di Vitest (WIP).

api

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

Avvia un server in ascolto sulla porta specificata per servire l'API. Se impostato su true, la porta predefinita è 51204.

browser

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

Esegue i test di Vitest all'interno di un browser. Per impostazione predefinita, viene utilizzato WebdriverIO per eseguire i test, ma è possibile configurare un provider diverso con l'opzione browser.provider.

NOTE

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

WARNING

Questa è una funzionalità sperimentale. Le modifiche che causano interruzioni potrebbero non seguire semver, si prega di fissare la versione di Vitest quando la si utilizza.

browser.enabled

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

Esegue tutti i test all'interno di un browser per impostazione predefinita. Può essere sovrascritto con l'opzione poolMatchGlobs.

browser.name

Tipo: string
CLI: --browser=safari

Esegue tutti i test in uno specifico browser. 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

browser.headless

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

Esegue il browser in modalità headless. Se Vitest viene eseguito in un ambiente CI (Continuous Integration), questa opzione è abilitata per impostazione predefinita.

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 serve il codice nel browser. Questa opzione non influisce sull'opzione test.api.

browser.provider

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

Percorso del provider che verrà utilizzato per l'esecuzione dei test nel browser. Vitest fornisce due provider: webdriverio (predefinito) e playwright. I provider personalizzati devono essere esportati utilizzando l'esportazione default e avere la seguente forma:

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

WARNING

Questa è un'API avanzata per gli sviluppatori di librerie. Se si desidera semplicemente eseguire test in un browser, utilizzare l'opzione browser.

browser.slowHijackESM

Tipo: boolean
Predefinito: true
Versione: Da Vitest 0.31.0

Quando i test vengono eseguiti in Node.js, Vitest può sfruttare la sua risoluzione interna dei moduli per simulare facilmente i moduli tramite la sintassi vi.mock. Tuttavia, replicare la risoluzione dei moduli ES nel browser è più complesso e richiede la trasformazione dei file sorgente prima che possano essere utilizzati dal browser.

Questa opzione non ha effetto sui test eseguiti in Node.js.

È abilitata per impostazione predefinita quando l'esecuzione avviene nel browser. Se non si utilizzano le funzionalità di spying sui moduli ES tramite vi.spyOn e non si utilizza vi.mock, è possibile disabilitare questa opzione per migliorare leggermente le prestazioni.

clearMocks

Tipo: boolean
Predefinito: false

Chiama .mockClear() su tutti gli spy prima di ogni test. Questo cancella la cronologia dei mock, ma non ne ripristina l'implementazione a quella predefinita.

mockReset

Tipo: boolean
Predefinito: false

Chiama .mockReset() su tutti gli spy prima di ogni test. Questo cancella la cronologia dei mock e ripristina l'implementazione a una funzione vuota che restituisce undefined.

restoreMocks

Tipo: boolean
Predefinito: false

Chiama .mockRestore() su tutti gli spy prima di ogni test. Questo cancella la cronologia dei mock e ripristina l'implementazione a quella originale predefinita.

unstubEnvs

Tipo: boolean
Predefinito: false
Versione: Da Vitest 0.26.0

Chiama vi.unstubAllEnvs prima di ogni test.

unstubGlobals

Tipo: boolean
Predefinito: false
Versione: Da Vitest 0.26.0

Chiama vi.unstubAllGlobals prima di ogni test.

testTransformMode

Tipo: { web?, ssr? }
Versione: Da Vitest 0.34.0

Definisce 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: []

Applica la pipeline di trasformazione SSR a tutti i moduli 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 (orientata al browser), quindi effettua una riscrittura SSR per consentire l'esecuzione del codice in Node. 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.

resolveSnapshotPath*

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

Permette di sovrascrivere il percorso predefinito dello 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: false
CLI: --allowOnly, --allowOnly=false

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

dangerouslyIgnoreUnhandledErrors*

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

Ignora qualsiasi errore non gestito che si verifichi.

passWithNoTests*

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

Vitest non segnalerà un errore se non vengono trovati test.

logHeapUsage

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

Mostra l'utilizzo dell'heap dopo ogni test. Utile per il debug di memory leak.

css

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

Definisce se il CSS deve essere elaborato. Se esclusi, i file CSS saranno sostituiti con stringhe vuote per evitare l'elaborazione successiva. I CSS Modules restituiranno un proxy per non influire sul runtime.

css.include

Tipo: RegExp | RegExp[]
Predefinito: []

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

TIP

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

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 sceglie di elaborare i file CSS, è possibile definire se i nomi delle classi all'interno dei CSS modules debbano essere 'scoped'. È possibile scegliere una delle opzioni:

stable: i nomi delle classi verranno generati come _${name}_${hashedFilename}. Ciò significa che la classe generata rimarrà invariata se il contenuto CSS viene modificato, ma cambierà se viene modificato il nome del file o se il file viene spostato in un'altra cartella. Questa impostazione è utile se si utilizza la funzionalità snapshot.
scoped: i nomi delle classi verranno generati come al solito, rispettando il metodo css.modules.generateScopeName, se ne è stato definito uno e l'elaborazione CSS è abilitata. Per impostazione predefinita, il nome del file verrà generato come _${name}_${hash}, dove l'hash include il nome del file e il contenuto del file.
non-scoped: i nomi delle classi non verranno sottoposti a hashing.

WARNING

Di default, Vitest esporta un proxy, evitando l'elaborazione dei CSS Modules. Se si fa affidamento sulle proprietà CSS nelle classi, è necessario abilitare l'elaborazione CSS utilizzando l'opzione include.

maxConcurrency

Tipo: number
Predefinito: 5

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

I test al di sopra di questo limite verranno messi in coda per essere eseguiti quando si libera uno slot disponibile.

cache*

Tipo: false | { dir? }

Opzioni per configurare la politica di cache di Vitest. Attualmente, Vitest memorizza nella cache i risultati dei test per dare priorità all'esecuzione dei test più lunghi e di quelli falliti.

cache.dir

Tipo: string
Predefinito: node_modules/.vitest

Percorso della directory della cache.

sequence

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

Opzioni per definire l'ordinamento dei test.

È possibile fornire opzioni di sequenza alla CLI con la notazione punto:

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

sequence.sequencer*

Tipo: TestSequencerConstructor
Predefinito: BaseSequencer

Una classe personalizzata che definisce i metodi per lo sharding e l'ordinamento dei test. È possibile estendere BaseSequencer da vitest/node se è necessario ridefinire solo uno dei metodi sort e shard, ma entrambi devono esistere.

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

sequence.shuffle

Tipo: boolean
Predefinito: false
CLI: --sequence.shuffle, --sequence.shuffle=false

Per eseguire i test in ordine casuale, è possibile abilitare questa opzione o utilizzare l'argomento CLI --sequence.shuffle.

Vitest di solito utilizza la cache per ordinare i test, quindi i test che impiegano più tempo iniziano prima: questo velocizza i test. Se i test vengono eseguiti in ordine casuale, si perderà questo miglioramento delle prestazioni, ma potrebbe essere utile per tenere traccia dei test che dipendono accidentalmente da un'altra esecuzione precedente.

sequence.concurrent

Tipo: boolean
Predefinito: false
CLI: --sequence.concurrent, --sequence.concurrent=false
Versione: Da Vitest 0.32.2

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

sequence.seed*

Tipo: number
Predefinito: Date.now()
CLI: --sequence.seed=1000

Imposta il seed di randomizzazione se i test vengono eseguiti in ordine casuale.

sequence.hooks

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

Permette di modificare l'ordine di esecuzione degli hook.

stack ordinerà gli hook "after" in ordine inverso, mentre gli hook "before" verranno eseguiti 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).

sequence.setupFiles

Tipo: 'list' | 'parallel'
Predefinito: 'parallel'
CLI: --sequence.setupFiles=<value>
Versione: Da Vitest 0.29.3

Modifica l'ordine in cui vengono eseguiti i 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.checker

Tipo: 'tsc' | 'vue-tsc' | string
Predefinito: tsc

Definisce quali strumenti utilizzare per il type checking. Il checker dovrebbe implementare lo stesso formato di output di tsc.

È necessario avere un pacchetto installato per utilizzare il type checker:

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

È anche possibile passare un percorso a un binario personalizzato o al nome di un comando che produce lo stesso output di tsc --noEmit --pretty false.

typecheck.include

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

Pattern Glob per i file che devono essere considerati file di test.

typecheck.exclude

Tipo: string[]
Predefinito: ['**/node_modules/**', '**/dist/**', '**/cypress/**', '**/.{idea,git,cache,output,temp}/**']

Pattern Glob per i file che non devono essere considerati file di test.

typecheck.allowJs

Tipo: boolean
Predefinito: false

Controlla i file JS che hanno il commento @ts-check. Se è abilitato in tsconfig, questo non lo sovrascriverà.

typecheck.ignoreSourceErrors

Tipo: boolean
Predefinito: false

Non segnalare un errore se Vitest rileva errori al di fuori dei file di test. Questo non mostrerà affatto errori non relativi ai test.

Per impostazione predefinita, se Vitest trova un errore di origine, la suite di test fallirà.

typecheck.tsconfig

Tipo: string
Predefinito: Tenta di individuare il file tsconfig.json più vicino

Percorso del tsconfig personalizzato, relativo alla root del progetto.

slowTestThreshold*

Tipo: number
Predefinito: 300

Il numero di millisecondi dopo il quale un test è considerato lento e segnalato come tale nei risultati.

chaiConfig

Tipo: { includeStack?, showDiff?, truncateThreshold? }
Predefinito: { includeStack: false, showDiff: true, truncateThreshold: 40 }
Versione: Da Vitest 0.30.0

Equivalente alla configurazione di Chai.

chaiConfig.includeStack

Tipo: boolean
Predefinito: false

Definisce se la stack trace deve essere inclusa nel messaggio di errore Assertion. Il valore predefinito false sopprime la stack trace nel messaggio di errore.

chaiConfig.showDiff

Tipo: boolean
Predefinito: true

Definisce se il flag showDiff deve essere incluso negli AssertionErrors generati. false sarà sempre false; true sarà true quando l'asserzione ha richiesto che venga mostrata una differenza.

chaiConfig.truncateThreshold

Tipo: number
Predefinito: 40

Imposta la soglia di lunghezza per i valori effettivi e previsti negli errori di asserzione. Se questa soglia viene superata, ad esempio per strutture di dati di grandi dimensioni, il valore viene sostituito con qualcosa come [ Array(3) ] o { Object (prop1, prop2) }. Impostarlo su 0 se si desidera disabilitare del tutto il troncamento.

Questa opzione di configurazione riguarda il troncamento dei valori nei titoli test.each e all'interno del messaggio di errore delle asserzioni.

bail

Tipo: number
Predefinito: 0
CLI: --bail=<value>
Versione: Da Vitest 0.31.0

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

Questo comportamento potrebbe non essere desiderabile per le build CI, dove l'obiettivo è ottenere build di successo al 100% e si desidera interrompere l'esecuzione dei test il prima possibile in caso di errori. L'opzione bail può essere utilizzata per accelerare le esecuzioni CI impedendo di eseguire più test quando si sono verificati errori.

retry

Tipo: number
Predefinito: 0
CLI: --retry=<value>
Versione: Da Vitest 0.32.3

Riprova ad eseguire il test per un numero specifico di volte in caso di fallimento.

onConsoleLog

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

Handler personalizzato per console.log nei test. Se si restituisce 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 {
      if (log === 'message from third party library' && type === 'stdout')
        return false;
    },
  },
});

diff

Tipo: string
CLI: --diff=<value>
Versione: Da Vitest 0.34.5

Percorso di un file di configurazione 'diff' che verrà utilizzato per generare l'interfaccia 'diff'. Utile se si desidera 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',
  },
});

Configurazione di Vitest ​

Configurazione ​

Opzioni ​

include ​

exclude ​

includeSource ​

server ​

server.sourcemap ​

server.debug ​

server.debug.dumpModules ​

server.debug.loadDumppedModules ​

server.deps ​

server.deps.external ​

server.deps.inline ​

server.deps.fallbackCJS ​

server.deps.cacheDir ​

deps ​

deps.optimizer ​

deps.optimizer.{mode}.enabled ​

deps.web ​

deps.web.transformAssets ​

deps.web.transformCss ​

deps.web.transformGlobPattern ​

deps.registerNodeLoader* ​

deps.interopDefault ​

deps.moduleDirectories ​

runner ​

benchmark ​

benchmark.include ​

benchmark.exclude ​

benchmark.includeSource ​

benchmark.reporters ​

benchmark.outputFile ​

alias ​

globals ​

environment ​

environmentOptions ​

environmentMatchGlobs ​

poolMatchGlobs ​

update* ​

watch* ​

root ​

reporters* ​

outputFile* ​

experimentalVmThreads ​

experimentalVmWorkerMemoryLimit ​

threads ​

singleThread ​

maxThreads* ​

minThreads* ​

useAtomics* ​

testTimeout ​

hookTimeout ​

teardownTimeout* ​

silent* ​

setupFiles ​

globalSetup ​

watchExclude* ​

forceRerunTriggers* ​

isolate ​

copertura* ​

coverage.provider ​

coverage.enabled ​

coverage.include ​

coverage.extension ​

coverage.exclude ​

coverage.all ​

coverage.clean ​

coverage.cleanOnRerun ​

coverage.reportsDirectory ​

coverage.reporter ​

coverage.reportOnFailure ​

coverage.allowExternal ​

coverage.skipFull ​

coverage.perFile ​

coverage.thresholdAutoUpdate ​

coverage.lines ​

coverage.functions ​

coverage.branches ​

coverage.statements ​

Configurazione di Vitest

Configurazione

Opzioni

include

exclude

includeSource

server

server.sourcemap

server.debug

server.debug.dumpModules

server.debug.loadDumppedModules

server.deps

server.deps.external

server.deps.inline

server.deps.fallbackCJS

server.deps.cacheDir

deps

deps.optimizer

deps.optimizer.{mode}.enabled

deps.web

deps.web.transformAssets

deps.web.transformCss

deps.web.transformGlobPattern

deps.registerNodeLoader*

deps.interopDefault

deps.moduleDirectories

runner

benchmark

benchmark.include

benchmark.exclude

benchmark.includeSource

benchmark.reporters

benchmark.outputFile

alias

globals

environment

environmentOptions

environmentMatchGlobs

poolMatchGlobs

update*

watch*

root

reporters*

outputFile*

experimentalVmThreads

experimentalVmWorkerMemoryLimit

threads

singleThread

maxThreads*

minThreads*

useAtomics*

testTimeout

hookTimeout

teardownTimeout*

silent*

setupFiles

globalSetup

watchExclude*

forceRerunTriggers*

isolate

copertura*

coverage.provider

coverage.enabled

coverage.include

coverage.extension

coverage.exclude

coverage.all

coverage.clean

coverage.cleanOnRerun

coverage.reportsDirectory

coverage.reporter

coverage.reportOnFailure

coverage.allowExternal

coverage.skipFull

coverage.perFile

coverage.thresholdAutoUpdate

coverage.lines

coverage.functions

coverage.branches

coverage.statements