Funzionalità

Configurazione, trasformatori, resolver e plugin di Vite.
Utilizza la stessa configurazione della tua app per l'esecuzione dei test!
Modalità watch intelligente e istantanea, simile all'HMR (Hot Module Replacement) per i test!
Test dei componenti per Vue, React, Svelte, Lit e altro ancora
Supporto immediato per TypeScript e JSX
ESM first, con supporto per top-level await
Multi-threading dei worker con Tinypool
Supporto per benchmark con Tinybench
Filtraggio, timeout e concorrenza per suite e test
Supporto per Workspace
Snapshot compatibili con Jest
Chai integrato per le asserzioni + API compatibili con Jest expect
Tinyspy integrato per il mocking
happy-dom o jsdom per il mocking del DOM e delle API del browser
Copertura del codice tramite v8 o istanbul
Test nel codice sorgente come in Rust
Type testing tramite expect-type

Impara a scrivere il tuo primo test con questo video

Configurazione condivisa tra test, sviluppo e build

Utilizza la configurazione, i trasformatori, i resolver e i plugin di Vite per eseguire i test. Sfrutta la stessa configurazione della tua app per i test.

Scopri di più in Configurazione di Vitest.

Modalità watch

bash

$ vitest

Quando modifichi il codice sorgente o i file di test, Vitest analizza in modo intelligente il grafo dei moduli e riesegue solo i test correlati, proprio come l'HMR in Vite!

vitest si avvia in modalità watch per impostazione predefinita nell'ambiente di sviluppo e in modalità run nell'ambiente CI (quando process.env.CI è presente). Puoi usare vitest watch o vitest run per specificare esplicitamente la modalità desiderata.

Funzionalità web comuni pronte all'uso

Supporto immediato per ES Module, TypeScript, JSX e PostCSS.

Thread

Multi-threading dei worker con Tinypool (un fork leggero di Piscina), che consente l'esecuzione simultanea dei test. I thread sono attivi di default in Vitest e possono essere disabilitati passando --no-threads nella CLI (Command Line Interface).

Vitest isola anche l'ambiente di ogni file, in modo che le modifiche all'ambiente in un file non influenzino gli altri. L'isolamento può essere disabilitato passando --no-isolate nella CLI, sacrificando la correttezza per prestazioni migliori.

Filtraggio dei test

Vitest offre diversi modi per restringere i test da eseguire e accelerare il processo di testing, permettendoti di concentrarti sullo sviluppo.

Scopri di più su Filtraggio dei test.

Esecuzione concorrente dei test

Utilizza .concurrent in test consecutivi per eseguirli in parallelo.

import { describe, it } from 'vitest';

// I due test contrassegnati come concorrenti verranno eseguiti in parallelo
describe('suite', () => {
  it('serial test', async () => {
    /* ... */
  });
  it.concurrent('concurrent test 1', async ({ expect }) => {
    /* ... */
  });
  it.concurrent('concurrent test 2', async ({ expect }) => {
    /* ... */
  });
});

Se utilizzi .concurrent su una suite, ogni test al suo interno verrà eseguito in parallelo.

import { describe, it } from 'vitest';

// Tutti i test all'interno di questa suite verranno eseguiti in parallelo
describe.concurrent('suite', () => {
  it('concurrent test 1', async ({ expect }) => {
    /* ... */
  });
  it('concurrent test 2', async ({ expect }) => {
    /* ... */
  });
  it.concurrent('concurrent test 3', async ({ expect }) => {
    /* ... */
  });
});

Puoi anche usare .skip, .only e .todo con suite e test concorrenti. Leggi di più nel Riferimento API.

WARNING

Quando si eseguono test concorrenti, gli snapshot e le asserzioni devono usare expect dal Contesto di test locale per garantire che venga rilevato il test corretto.

Snapshot

Supporto per gli snapshot compatibili con Jest.

import { expect, it } from 'vitest';

it('renders correctly', () => {
  const result = render();
  expect(result).toMatchSnapshot();
});

Scopri di più su Snapshot.

Compatibilità con Chai e Jest `expect`

Chai è integrato per le asserzioni, insieme alle API compatibili con Jest expect.

Nota: se utilizzi librerie di terze parti che aggiungono matcher, impostare test.globals su true fornirà una migliore compatibilità.

Mocking

Tinyspy è integrato per il mocking con API compatibili con jest sull'oggetto vi.

import { expect, vi } from 'vitest';

const fn = vi.fn();

fn('hello', 1);

expect(vi.isMockFunction(fn)).toBe(true);
expect(fn.mock.calls[0]).toEqual(['hello', 1]);

fn.mockImplementation(arg => arg);

fn('world', 2);

expect(fn.mock.results[1].value).toBe('world');

Vitest supporta sia happy-dom che jsdom per il mocking del DOM e delle API del browser. Non sono inclusi in Vitest, quindi potrebbe essere necessario installarli:

bash

$ npm i -D happy-dom
# or
$ npm i -D jsdom

Successivamente, modifica l'opzione environment nel file di configurazione:

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

export default defineConfig({
  test: {
    environment: 'happy-dom', // or 'jsdom', 'node'
  },
});

Scopri di più sul Mocking.

Copertura

Vitest supporta la copertura del codice nativa tramite v8 e la copertura del codice strumentata tramite istanbul.

json

{
  "scripts": {
    "test": "vitest",
    "coverage": "vitest run --coverage"
  }
}

Scopri di più sulla Coverage.

Test nel codice sorgente

Vitest offre anche un modo per eseguire test all'interno del codice sorgente insieme all'implementazione, in modo simile ai test dei moduli in Rust.

Questo consente ai test di condividere la stessa closure delle implementazioni e di testare gli stati privati senza doverli esportare. Allo stesso tempo, avvicina anche il ciclo di feedback per lo sviluppo.

// src/index.ts

// l'implementazione
export function add(...args: number[]) {
  return args.reduce((a, b) => a + b, 0);
}

// test nel codice sorgente
if (import.meta.vitest) {
  const { it, expect } = import.meta.vitest;
  it('add', () => {
    expect(add()).toBe(0);
    expect(add(1)).toBe(1);
    expect(add(1, 2, 3)).toBe(6);
  });
}

Scopri di più sul In-source testing.

Benchmark ^experimental

A partire dalla versione 0.23.0 di Vitest, puoi utilizzare la funzione bench con Tinybench per eseguire benchmark e confrontare le prestazioni.

import { bench, describe } from 'vitest';

describe('sort', () => {
  bench('normal', () => {
    const x = [1, 5, 4, 2, 3];
    x.sort((a, b) => {
      return a - b;
    });
  });

  bench('reverse', () => {
    const x = [1, 5, 4, 2, 3];
    x.reverse().sort((a, b) => {
      return a - b;
    });
  });
});

Type testing ^experimental

Dalla versione 0.25.0 di Vitest puoi scrivere test per individuare le regressioni dei tipi. Vitest viene fornito con il pacchetto expect-type per fornirti un'API simile e facile da capire.

import { assertType, expectTypeOf } from 'vitest';
import { mount } from './mount.js';

test('my types work properly', () => {
  expectTypeOf(mount).toBeFunction();
  expectTypeOf(mount).parameter(0).toMatchTypeOf<{ name: string }>();

  // @ts-expect-error name is a string
  assertType(mount({ name: 42 }));
});

Funzionalità ​

Configurazione condivisa tra test, sviluppo e build ​

Modalità watch ​

Funzionalità web comuni pronte all'uso ​

Thread ​

Filtraggio dei test ​

Esecuzione concorrente dei test ​

Snapshot ​

Compatibilità con Chai e Jest expect ​

Mocking ​

Copertura ​

Test nel codice sorgente ​

Benchmark experimental ​

Type testing experimental ​