Recursos

Configuração, transformadores, resolvedores e plugins do Vite.
Utilize a mesma configuração do seu aplicativo para executar os testes!
Modo de observação inteligente e instantâneo, similar ao HMR (Hot Module Replacement) do Vite para testes!
Teste de componentes para Vue, React, Svelte, Lit e muito mais
Suporte imediato a TypeScript e JSX
ESM (ECMAScript Modules) em primeiro lugar, top level await
Multithreading com Workers via Tinypool
Suporte para benchmarking com Tinybench
Filtragem, tempos limite, execução concorrente para suítes e testes
Suporte a Workspace
Snapshot compatível com Jest
Chai integrado para asserções + APIs compatíveis com Jest expect
Tinyspy integrado para mocking
happy-dom ou jsdom para simulação de DOM (DOM mocking)
Cobertura de código via v8 ou istanbul
Teste in-source similar ao Rust
Teste de Tipos via expect-type

Aprenda como escrever seu primeiro teste em vídeo

Configuração compartilhada entre teste, desenvolvimento e build

Configuração, transformadores, resolvedores e plugins do Vite. Utilize a mesma configuração do seu aplicativo para executar os testes.

Saiba mais em Configurando o Vitest.

Modo de Observação (Watch Mode)

bash

$ vitest

Quando você modifica seu código fonte ou os arquivos de teste, o Vitest analisa inteligentemente o grafo de módulos e executa novamente apenas os testes relacionados, assim como o HMR funciona no Vite!

vitest inicia em watch mode (modo de observação) por padrão no ambiente de desenvolvimento e em run mode (modo de execução) no ambiente de CI (Integração Contínua) (quando process.env.CI está definido) de forma inteligente. Você pode usar vitest watch ou vitest run para especificar explicitamente o modo desejado.

Recursos web comuns já inclusos

Suporte imediato para ES Module / TypeScript / JSX / PostCSS

Threads (Threads)

Por padrão, o Vitest executa arquivos de teste em várias threads usando node:worker_threads através do Tinypool (um fork leve do Piscina), permitindo que os testes sejam executados simultaneamente. Se o seu código de teste não for compatível com multi-threading, você pode mudar para --pool=forks que executa testes em múltiplos processos usando node:child_process através do Tinypool.

Para executar testes em uma única thread ou processo, consulte poolOptions.

O Vitest também isola o ambiente de cada arquivo para que as mutações de ambiente em um arquivo não afetem outros. O isolamento pode ser desabilitado passando --no-isolate para a CLI (sacrificando a precisão em prol do desempenho).

Filtragem de Testes

O Vitest oferece diversas maneiras de restringir os testes executados, acelerando o processo e permitindo que você se concentre no desenvolvimento.

Saiba mais sobre Filtragem de Testes.

Executando testes concorrentemente

Use .concurrent em testes consecutivos para executá-los simultaneamente.

import { describe, it } from 'vitest';

// Os dois testes marcados com concurrent serão executados em paralelo
describe('suite', () => {
  it('serial test', async () => {
    /* ... */
  });
  it.concurrent('concurrent test 1', async ({ expect }) => {
    /* ... */
  });
  it.concurrent('concurrent test 2', async ({ expect }) => {
    /* ... */
  });
});

Se você usar .concurrent em uma suíte, todos os testes dentro dela serão executados em paralelo.

import { describe, it } from 'vitest';

// Todos os testes dentro desta suíte serão executados em paralelo
describe.concurrent('suite', () => {
  it('concurrent test 1', async ({ expect }) => {
    /* ... */
  });
  it('concurrent test 2', async ({ expect }) => {
    /* ... */
  });
  it.concurrent('concurrent test 3', async ({ expect }) => {
    /* ... */
  });
});

Você também pode usar .skip, .only e .todo com suítes e testes concorrentes. Leia mais na Referência da API.

WARNING

Ao executar testes concorrentes, Snapshots e Assertions devem usar expect do Contexto de Teste local para garantir que o teste correto seja detectado.

Snapshot

Suporte a snapshot compatível com Jest.

import { expect, it } from 'vitest';

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

Saiba mais em Snapshot.

Compatibilidade com Chai e Jest `expect`

Chai é integrado para asserções, além de APIs compatíveis com Jest expect.

Observe que, se você estiver usando bibliotecas de terceiros que adicionam matchers (correspondências), definir test.globals como true fornecerá melhor compatibilidade.

Mocking (Simulação)

Tinyspy é integrado para mocking com APIs compatíveis com jest no objeto 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');

O Vitest suporta happy-dom ou jsdom para simular DOM e APIs do navegador. Eles não vêm com o Vitest, você pode precisar instalá-los:

bash

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

Depois disso, altere a opção environment no seu arquivo de configuração:

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

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

Saiba mais em Mocking.

Coverage (Cobertura de Código)

O Vitest suporta cobertura de código nativa via v8 e cobertura de código instrumentada via istanbul.

json

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

Saiba mais em Coverage.

In-source testing (Teste no código fonte)

O Vitest também oferece uma maneira de executar testes dentro do seu código fonte junto com a implementação, semelhante aos testes de módulo do Rust.

Isso faz com que os testes compartilhem o mesmo closure (fechamento) que as implementações e sejam capazes de testar em relação a estados privados sem exportar. Enquanto isso, também aproxima o loop de feedback para o desenvolvimento.

// src/index.ts

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

// in-source test suites
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);
  });
}

Saiba mais em In-source testing.

Teste de Desempenho experimental

Desde o Vitest 0.23.0, você pode executar testes de benchmark com a função bench via Tinybench para comparar os resultados de desempenho.

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

Teste de Tipos experimental

Desde o Vitest 0.25.0, você pode escrever testes para detectar regressões de tipo. O Vitest vem com o pacote expect-type para fornecer uma API semelhante e fácil de entender.

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

Recursos ​

Configuração compartilhada entre teste, desenvolvimento e build ​

Modo de Observação (Watch Mode) ​

Recursos web comuns já inclusos ​

Threads (Threads) ​

Filtragem de Testes ​

Executando testes concorrentemente ​

Snapshot ​

Compatibilidade com Chai e Jest expect ​

Mocking (Simulação) ​

Coverage (Cobertura de Código) ​

In-source testing (Teste no código fonte) ​

Teste de Desempenho experimental ​

Teste de Tipos experimental ​