Características

Configuración, transformadores, resolvedores y plugins de Vite.
¡Utiliza la misma configuración de tu aplicación para ejecutar las pruebas!
Modo de vigilancia instantáneo e inteligente, ¡como HMR para las pruebas!
Pruebas de componentes para Vue, React, Svelte, Lit y otros.
Soporte inmediato para TypeScript / JSX
Prioridad a ESM, uso de await en el nivel superior
Multi-hilo de Workers a través de Tinypool
Soporte para benchmarking (evaluación de rendimiento) con Tinybench
Filtrado, tiempos de espera y concurrencia para suites y pruebas
Soporte de Workspace
Instantáneas compatibles con Jest
Chai integrado para aserciones + APIs compatibles con Jest expect
Tinyspy integrado para simulación
happy-dom o jsdom para simulación de DOM
Cobertura a través de v8 o istanbul
Pruebas dentro del código fuente al estilo de Rust
Pruebas de tipos a través de expect-type

Aprende a escribir tu primera prueba en video

Configuración compartida para pruebas, desarrollo y construcción

Configuración, transformadores, resolvedores y plugins de Vite. Utiliza la misma configuración de tu aplicación para ejecutar las pruebas.

Obtén más información en Configuración de Vitest.

Modo de Vigilancia (Watch Mode)

bash

$ vitest

Cuando modificas tu código fuente o los archivos de prueba, Vitest analiza inteligentemente el grafo de módulos y solo vuelve a ejecutar las pruebas relacionadas, ¡tal como funciona HMR en Vite!

vitest se inicia en watch mode (modo de vigilancia por defecto en el entorno de desarrollo) y en run mode (modo de ejecución) en el entorno de CI (cuando process.env.CI está presente). Puedes utilizar vitest watch o vitest run para especificar explícitamente el modo deseado.

Modismos web comunes listos para usar

Soporte inmediato para ES Module / TypeScript / JSX / PostCSS

Hilos (Threads)

Por defecto, Vitest ejecuta los archivos de prueba en múltiples hilos utilizando node:worker_threads a través de Tinypool (una bifurcación ligera de Piscina), lo que permite que las pruebas se ejecuten simultáneamente. Si su código de prueba no es compatible con el multiproceso, puede cambiar a --pool=forks que ejecuta las pruebas en múltiples procesos utilizando node:child_process a través de Tinypool.

Para ejecutar las pruebas en un solo hilo o proceso, consulte poolOptions.

Vitest también aísla el entorno de cada archivo para que las mutaciones del entorno en un archivo no afecten a otros. El aislamiento se puede deshabilitar pasando --no-isolate a la CLI (sacrificando la corrección por el rendimiento de la ejecución).

Filtro de Pruebas

Vitest ofrece diversas formas de filtrar las pruebas que se ejecutarán, lo que permite acelerar el proceso y facilita la concentración en el desarrollo.

Obtén más información sobre Filtrado de Pruebas.

Ejecución concurrente de pruebas

Utiliza .concurrent en pruebas consecutivas para ejecutarlas en paralelo.

import { describe, it } from 'vitest';

// Las dos pruebas marcadas con concurrent se ejecutarán en paralelo
describe('suite', () => {
  it('serial test', async () => {
    /* ... */
  });
  it.concurrent('concurrent test 1', async ({ expect }) => {
    /* ... */
  });
  it.concurrent('concurrent test 2', async ({ expect }) => {
    /* ... */
  });
});

Si utilizas .concurrent en una suite, cada prueba dentro de ella se ejecutará en paralelo.

import { describe, it } from 'vitest';

// Todas las pruebas dentro de esta suite se ejecutarán en paralelo
describe.concurrent('suite', () => {
  it('concurrent test 1', async ({ expect }) => {
    /* ... */
  });
  it('concurrent test 2', async ({ expect }) => {
    /* ... */
  });
  it.concurrent('concurrent test 3', async ({ expect }) => {
    /* ... */
  });
});

También puedes usar .skip, .only y .todo con suites y pruebas concurrentes. Lee más en la Referencia de la API.

WARNING

Cuando se ejecutan pruebas concurrentes, las Instantáneas y las Aserciones deben usar expect del Contexto de Prueba local para asegurar que se detecte la prueba correcta.

Instantáneas (Snapshots)

Soporte de instantáneas compatible con Jest.

import { expect, it } from 'vitest';

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

Obtén más información en Instantánea.

Compatibilidad de Chai y Jest `expect`

Chai está integrado para aserciones, además de APIs compatibles con Jest expect.

Ten en cuenta que si estás utilizando bibliotecas de terceros que añaden comparadores, establecer test.globals a true proporcionará una mejor compatibilidad.

Simulación

Tinyspy está integrado para simulación con APIs compatibles con jest en el 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');

Vitest soporta tanto happy-dom como jsdom para simular el DOM y las APIs del navegador. No se incluyen con Vitest, por lo que es posible que necesites instalarlos:

bash

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

Después de eso, cambia la opción environment en tu archivo de configuración:

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

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

Obtén más información en Mocking.

Cobertura

Vitest soporta la cobertura de código nativo a través de v8 y la cobertura de código instrumentado a través de istanbul.

json

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

Obtén más información en Cobertura.

Pruebas en el código fuente

Vitest también proporciona una forma de ejecutar pruebas dentro de tu código fuente junto con la implementación, similar a las pruebas de módulo de Rust.

Esto permite que las pruebas compartan el mismo contexto que las implementaciones, posibilitando la evaluación de estados privados sin necesidad de exportarlos. A su vez, agiliza el ciclo de retroalimentación durante el desarrollo.

// src/index.ts

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

// conjuntos de pruebas en el código fuente
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);
  });
}

Obtén más información en Pruebas en el código fuente.

Pruebas de Rendimiento experimental

Desde Vitest 0.23.0, puedes ejecutar pruebas de rendimiento con la función bench a través de Tinybench para comparar los resultados de rendimiento.

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

Pruebas de Tipos experimental

Desde Vitest 0.25.0 puedes escribir pruebas para detectar regresiones de tipos. Vitest viene con el paquete expect-type para proporcionarte una API similar y 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 }));
});

Características ​

Configuración compartida para pruebas, desarrollo y construcción ​

Modo de Vigilancia (Watch Mode) ​

Modismos web comunes listos para usar ​

Hilos (Threads) ​

Filtro de Pruebas ​

Ejecución concurrente de pruebas ​

Instantáneas (Snapshots) ​

Compatibilidad de Chai y Jest expect ​

Simulación ​

Cobertura ​

Pruebas en el código fuente ​

Pruebas de Rendimiento experimental ​

Pruebas de Tipos experimental ​