Configuración de Vitest

Configuración

vitest leerá tu archivo vite.config.ts principal, si existe, para coincidir con los plugins y la configuración de tu aplicación Vite. Si deseas una configuración diferente para las pruebas, o si tu aplicación principal no depende de Vite, tienes las siguientes opciones:

Crear un archivo vitest.config.ts. Este archivo tendrá mayor prioridad y sobrescribirá la configuración de vite.config.ts.
Pasar el parámetro --config a la CLI. Por ejemplo: vitest --config ./path/to/vitest.config.ts.
Usar process.env.VITEST o la propiedad mode en defineConfig (se establecerá como test o benchmark si no se anula) para aplicar condicionalmente una configuración diferente en vite.config.ts.

Para configurar vitest, añade la propiedad test a tu configuración de Vite. Si estás importando defineConfig desde vite, también deberás añadir una referencia a los tipos de Vitest usando un comando de triple barra en la parte superior de tu archivo de configuración.

Si usas defineConfig desde vite, deberías hacer lo siguiente:

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

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

Si usas defineConfig desde vitest/config, deberías hacer lo siguiente:

import { defineConfig } from 'vitest/config';

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

Puedes recuperar las opciones predeterminadas de Vitest para expandirlas si es necesario:

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

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

Cuando utilices un archivo vitest.config.js separado, también puedes extender las opciones de Vite desde otro archivo de configuración, si es necesario:

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

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

WARNING

La utilidad mergeConfig está disponible en Vitest desde la v0.30.0. Si usas una versión anterior, puedes importarla directamente desde vite.

Si tu configuración de Vite está definida como una función, puedes definirla de la siguiente manera:

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

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

Opciones

TIP

Además de las siguientes opciones, también puedes usar cualquier opción de configuración de Vite. Por ejemplo, define para definir variables globales, o resolve.alias para definir alias.

TIP

Todas las opciones de configuración que no son compatibles dentro de la configuración de un proyecto workspace tienen la etiqueta *.

include

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

Patrones glob para los archivos que se incluirán en la ejecución de la prueba.

exclude

Tipo: string[]
Por defecto: ['**/node_modules/**', '**/dist/**', '**/cypress/**', '**/.{idea,git,cache,output,temp}/**', '**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build}.config.*']

Patrones glob para los archivos que se excluirán de la ejecución de la prueba.

includeSource

Tipo: string[]
Por defecto: []

Patrones glob para incluir archivos de prueba en el código fuente.

Cuando se define, Vitest ejecutará todos los archivos que coincidan con import.meta.vitest.

server

Tipo: { sourcemap?, deps?, ... }
Versión: Desde Vitest 0.34.0

Opciones para el servidor Vite-Node.

server.sourcemap

Tipo: 'inline' | boolean
Por defecto: 'inline'

Inyecta sourcemaps en línea a los módulos.

server.debug

Tipo: { dumpModules?, loadDumppedModules? }

Opciones del depurador de Vite-Node.

server.debug.dumpModules

Tipo: boolean | string

Volcar el módulo transformado al sistema de archivos. Si se proporciona una cadena, se volcará en la ruta especificada.

server.debug.loadDumppedModules

Tipo: boolean

Leer el módulo volcado del sistema de archivos si existe. Útil para depurar modificando el resultado del volcado en el sistema de archivos.

server.deps

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

Configuración para la resolución de dependencias.

server.deps.external

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

Externalizar significa que Vite no procesará el paquete directamente con sus transformadores, sino que dejará esta tarea a Node. Las dependencias externalizadas no aplicarán los transformadores y resolutores de Vite, por lo que no admiten HMR en la recarga. De forma predeterminada, todos los paquetes dentro de node_modules están externalizados.

Estas opciones admiten nombres de paquetes tal como están escritos en node_modules o especificados dentro de deps.moduleDirectories. Por ejemplo, el paquete @company/some-name ubicado dentro de packages/some-name debe especificarse como some-name, y packages debe incluirse en deps.moduleDirectories. Básicamente, Vitest siempre verifica la ruta del archivo, no el nombre real del paquete.

Si se usa una expresión regular, Vitest la aplicará a la ruta del archivo, no al nombre del paquete.

server.deps.inline

Tipo: (string | RegExp)[] | true
Por defecto: []

Vite procesará los módulos integrados. Esto puede ser útil para manejar paquetes que envían archivos .js en formato ESM (que Node no puede manejar).

Si se establece en true, cada dependencia se pondrá en línea. Todas las dependencias especificadas en ssr.noExternal se pondrán en línea de forma predeterminada.

server.deps.fallbackCJS

Tipo boolean
Por defecto: false

Cuando una dependencia es un paquete ESM válido, intenta adivinar la versión CJS basándose en la ruta. Esto puede ser útil si una dependencia tiene el archivo ESM incorrecto.

Esto puede causar una desalineación si un paquete tiene una lógica diferente en los modos ESM y CJS.

server.deps.cacheDir

Tipo string
Por defecto: 'node_modules/.vite'

Directorio para guardar los archivos de caché.

deps

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

Configuración para la resolución de dependencias.

deps.optimizer

Tipo: { ssr?, web? }
Versión: Desde Vitest 0.34.0
Ver también: Opciones de optimización de dependencias

Habilita la optimización de dependencias. Si tienes muchas pruebas, esto puede mejorar el rendimiento. Antes de Vitest 0.34.0, se llamaba deps.experimentalOptimizer.

Cuando Vitest encuentra la biblioteca externa listada en include, la empaquetará en un único archivo usando esbuild y la importará como un módulo completo. Esto es beneficioso por varias razones:

Importar paquetes con muchas importaciones es costoso. Al agruparlos en un solo archivo, podemos ahorrar tiempo.
Importar bibliotecas de interfaz de usuario es costoso porque no están diseñadas para ejecutarse dentro de Node.js.
Tu configuración de alias ahora se respeta dentro de los paquetes agrupados.
El código en tus pruebas se está ejecutando de forma más similar a como se ejecuta en el navegador.

Ten en cuenta que solo los paquetes en la opción deps.optimizer?.[mode].include están agrupados (algunos plugins lo rellenan automáticamente, como Svelte). Puedes leer más sobre las opciones disponibles en la documentación de Vite (Vitest no admite las opciones disable y noDiscovery). De forma predeterminada, Vitest usa optimizer.web para los entornos jsdom y happy-dom, y optimizer.ssr para los entornos node y edge, pero esto se puede configurar mediante transformMode.

Estas opciones también heredan tu configuración de optimizeDeps (para web, Vitest extenderá optimizeDeps, para ssr - ssr.optimizeDeps). Si redefines la opción include/exclude en deps.optimizer, extenderá tu optimizeDeps al ejecutar las pruebas. Vitest elimina automáticamente las mismas opciones de include si están listadas en exclude.

TIP

No podrás modificar el código en node_modules para depurar, ya que el código se encuentra realmente en tu directorio cacheDir o test.cache.dir. Si quieres depurar con sentencias console.log, edítalo directamente o fuerza la reagrupación con la opción deps.optimizer?.[mode].force.

deps.optimizer.{mode}.enabled

Tipo: boolean
Por defecto: true si se usa >= Vite 4.3.2, false en caso contrario

Habilita la optimización de dependencias.

WARNING

Esta opción solo es válida con Vite 4.3.2 y superior.

deps.web

Tipo: { transformAssets?, ... }
Versión: Desde Vite 0.34.2

Opciones que se aplican a los archivos externos cuando el modo de transformación se establece en web. De forma predeterminada, jsdom y happy-dom usan el modo web, mientras que los entornos node y edge usan el modo de transformación ssr, por lo que estas opciones no afectarán a los archivos dentro de esos entornos.

Por lo general, los archivos dentro de node_modules están externalizados, pero estas opciones también afectan a los archivos en server.deps.external.

deps.web.transformAssets

Tipo: boolean
Por defecto: true

¿Debería Vitest procesar y resolver los archivos de recursos (.png, .svg, .jpg, etc.) como lo hace Vite en el navegador?

Este módulo tendrá una exportación predeterminada igual a la ruta del activo, si no se indica ninguna consulta.

WARNING

Actualmente, esta opción solo funciona con el grupo experimentalVmThreads.

deps.web.transformCss

Tipo: boolean
Por defecto: true

¿Debería Vitest procesar y resolver los archivos CSS (.css, .scss, .sass, etc.) como lo hace Vite en el navegador?

Si los archivos CSS están desactivados con las opciones css, esta opción simplemente silenciará los errores ERR_UNKNOWN_FILE_EXTENSION.

WARNING

Actualmente, esta opción solo funciona con el grupo experimentalVmThreads.

deps.web.transformGlobPattern

Tipo: RegExp | RegExp[]
Por defecto: []

Patrón Regexp para coincidir con los archivos externos que deben transformarse.

De forma predeterminada, los archivos dentro de node_modules están externalizados y no se transforman, a menos que sea CSS o un activo, y la opción correspondiente no esté desactivada.

WARNING

Actualmente, esta opción solo funciona con el grupo experimentalVmThreads.

deps.registerNodeLoader*

Tipo: boolean
Por defecto: false

Usar Node loader experimental para resolver las importaciones dentro de los archivos externalizados, usando el algoritmo de resolución de Vite.

Si está desactivado, tu alias y <plugin>.resolveId no afectarán a las importaciones dentro de los paquetes externalizados (por defecto, node_modules).

deps.interopDefault

Tipo: boolean
Por defecto: true

Interpretar la exportación predeterminada de los módulos CJS como exportaciones con nombre. Algunas dependencias solo agrupan módulos CJS y no usan exportaciones con nombre que Node.js puede analizar estáticamente cuando un paquete se importa usando la sintaxis import en lugar de require. Al importar tales dependencias en el entorno Node usando exportaciones con nombre, verás este error:

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 no realiza análisis estático y no puede fallar antes de que se ejecute tu código, por lo que es muy probable que veas este error al ejecutar las pruebas si esta función está desactivada:

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

De forma predeterminada, Vitest asume que utilizas un bundler para evitar esto y no fallará, pero puedes desactivar este comportamiento manualmente si tu código no se procesa.

deps.moduleDirectories

Tipo: string[]
Por defecto: ['node_modules']

Una lista de directorios que deben tratarse como directorios de módulos. Esta opción de configuración afecta el comportamiento de vi.mock: cuando no se especifica una fábrica y la ruta de lo que estás simulando coincide con uno de los valores de moduleDirectories, Vitest intentará resolver la simulación buscando una carpeta __mocks__ en la raíz del proyecto.

Esta opción también afectará si un archivo debe tratarse como un módulo al externalizar dependencias. De forma predeterminada, Vitest importa módulos externos con Node.js nativo omitiendo el paso de transformación de Vite.

Establecer esta opción anulará el valor predeterminado. Si deseas seguir buscando paquetes en node_modules, inclúyelo junto con cualquier otra opción:

import { defineConfig } from 'vitest/config';

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

runner

Tipo: VitestRunnerConstructor
Por defecto: node al ejecutar pruebas, o benchmark al ejecutar benchmarks

Ruta a un ejecutor de pruebas personalizado. Esta es una característica avanzada y debe usarse con ejecutores de bibliotecas personalizadas. Puedes leer más sobre esto en la documentación.

benchmark

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

Opciones usadas al ejecutar vitest bench.

benchmark.include

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

Patrones glob para incluir archivos de prueba de benchmark.

benchmark.exclude

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

Patrones glob para excluir archivos de prueba de benchmark.

benchmark.includeSource

Tipo: string[]
Por defecto: []

Patrones glob para incluir archivos de prueba de benchmark en el código fuente. Esta opción es similar a includeSource.

Cuando se define, Vitest ejecutará todos los archivos que coincidan con import.meta.vitest.

benchmark.reporters

Tipo: Arrayable<BenchmarkBuiltinReporters | Reporter>
Por defecto: 'default'

Informe personalizado para los resultados. Puede contener uno o más nombres de informes integrados, instancias de reporteros y/o rutas a reporteros personalizados.

benchmark.outputFile

Tipo: string | Record<string, string>

Escribe los resultados del punto de referencia en un archivo cuando también se especifica la opción --reporter=json. Al proporcionar un objeto en vez de una cadena, puedes definir salidas individuales cuando uses varios reporteros.

Para proporcionar un objeto a través del comando CLI, usa la siguiente sintaxis: --outputFile.json=./path --outputFile.junit=./other-path.

alias

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

Define alias personalizados al ejecutar dentro de las pruebas. Se fusionarán con los alias de resolve.alias.

globals

Tipo: boolean
Por defecto: false
CLI: --globals, --globals=false

De forma predeterminada, vitest no proporciona APIs globales para ser más explícito. Si prefieres usar las APIs globalmente como Jest, tienes la opción de pasar la opción --globals a la CLI o añadir globals: true en la configuración.

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

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

Para que TypeScript funcione con las APIs globales, añade vitest/globals al campo types en tu tsconfig.json.

json

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

Si ya estás usando unplugin-auto-import en tu proyecto, también puedes usarlo directamente para importar automáticamente esas APIs.

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

export default defineConfig({
  plugins: [
    AutoImport({
      imports: ['vitest'],
      dts: true, // generar la declaración de TypeScript
    }),
  ],
});

environment

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

Define el entorno que se utilizará para las pruebas. El entorno predeterminado en Vitest es Node.js. Si está desarrollando una aplicación web, puede utilizar un entorno similar al navegador con jsdom o happy-dom. Para funciones edge, puede usar el entorno edge-runtime.

Puede especificar un entorno diferente para todas las pruebas de un archivo añadiendo un docblock @vitest-environment o un comentario en la parte superior del archivo:

Formato Docblock:

/**
 * @vitest-environment jsdom
 */

test('usar jsdom en este archivo de prueba', () => {
  const element = document.createElement('div');
  expect(element).not.toBeNull();
});

Formato Comentario:

// @vitest-environment happy-dom

test('usar happy-dom en este archivo de prueba', () => {
  const element = document.createElement('div');
  expect(element).not.toBeNull();
});

Para compatibilidad con Jest, también se admite @jest-environment:

/**
 * @jest-environment jsdom
 */

test('usar jsdom en este archivo de prueba', () => {
  const element = document.createElement('div');
  expect(element).not.toBeNull();
});

Si ejecuta Vitest con el flag --threads=false, las pruebas se ejecutarán en este orden: node, jsdom, happy-dom, edge-runtime, custom environments. Esto significa que las pruebas con el mismo entorno se agrupan, pero se ejecutan secuencialmente.

A partir de la versión 0.23.0, también puede definir un entorno personalizado. Cuando se utiliza un entorno no integrado, Vitest intentará cargar el paquete vitest-environment-${name}. Este paquete debe exportar un objeto con la forma de Environment:

import type { Environment } from 'vitest';

export default <Environment>{
  name: 'custom',
  transformMode: 'ssr',
  setup() {
    // configuración personalizada
    return {
      teardown() {
        // se llama después de que se hayan ejecutado todas las pruebas con este entorno
      },
    };
  },
};

Vitest también expone builtinEnvironments a través de la entrada vitest/environments, en caso de que solo quiera extenderlo. Puede leer más sobre la extensión de entornos en nuestra guía.

environmentOptions

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

Estas opciones se pasan al método setup del environment actual. Por defecto, solo puede configurar las opciones de JSDOM si lo está utilizando como su entorno de prueba.

environmentMatchGlobs

Tipo: [string, EnvironmentName][]
Predeterminado: []

Asigna automáticamente el entorno basándose en patrones glob. Se utilizará la primera coincidencia.

Por ejemplo:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    environmentMatchGlobs: [
      // todas las pruebas en tests/dom se ejecutarán en jsdom
      ['tests/dom/**', 'jsdom'],
      // todas las pruebas en tests/ con .edge.test.ts se ejecutarán en edge-runtime
      ['**/*.edge.test.ts', 'edge-runtime'],
      // ...
    ],
  },
});

poolMatchGlobs

Tipo: [string, 'threads' | 'child_process' | 'experimentalVmThreads'][]
Predeterminado: []
Versión: Desde Vitest 0.29.4

Asigna automáticamente el pool en el que se ejecutarán las pruebas basándose en patrones glob. Se utilizará la primera coincidencia.

Por ejemplo:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolMatchGlobs: [
      // todas las pruebas en el directorio "worker-specific" se ejecutarán dentro de un worker como si habilitaras `--threads` para ellas,
      ['**/tests/worker-specific/**', 'threads'],
      // ejecuta todas las pruebas en el directorio "browser" en un navegador real
      ['**/tests/browser/**', 'browser'],
      // todas las demás pruebas se ejecutarán basándose en las opciones "browser.enabled" y "threads", si no especificaste otros globs
      // ...
    ],
  },
});

update*

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

Actualiza los archivos de snapshots. Esto actualizará todos los snapshots modificados y eliminará los obsoletos.

watch*

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

Habilita el modo watch.

root

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

Raíz del proyecto.

reporters*

Tipo: Reporter | Reporter[]
Predeterminado: 'default'
CLI: --reporter=<nombre>, --reporter=<nombre1> --reporter=<nombre2>

Reporters personalizados para la salida. Los reporters pueden ser una instancia de Reporter o una cadena para seleccionar reporters integrados:

'default' - Colapsa los suites cuando pasan.
'basic' - Proporciona un reporter similar al reporter predeterminado en CI (Integración Continua).
'verbose' - Mantiene el árbol de tareas completo visible.
'dot' - Muestra cada tarea como un solo punto.
'junit' - Reportero JUnit XML (puede configurar el nombre de la etiqueta testsuites con la variable de entorno VITEST_JUNIT_SUITE_NAME, y la propiedad de la etiqueta classname con VITEST_JUNIT_CLASSNAME).
'json' - Da un resumen JSON simple.
'html' - Genera un informe HTML basado en @vitest/ui.
'hanging-process' - Muestra una lista de procesos bloqueados si Vitest no puede salir del proceso de forma segura. Esta podría ser una operación pesada, habilítela solo si Vitest no puede salir del proceso de forma consistente.
ruta de un reporter personalizado (ej. './path/to/reporter.ts', '@scope/reporter')

outputFile*

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

Escribe los resultados de las pruebas en un archivo cuando también se especifica la opción --reporter=json, --reporter=html o --reporter=junit. Al proporcionar un objeto en lugar de una cadena, puede definir salidas individuales cuando se utilizan varios reporters.

experimentalVmThreads

Tipo: boolean
CLI: --experimentalVmThreads, --experimental-vm-threads
Versión: Desde Vitest 0.34.0

Ejecuta las pruebas utilizando VM context (dentro de un entorno sandbox) en un pool de workers.

Esto permite que las pruebas se ejecuten más rápido, pero el módulo VM es inestable al ejecutar código ESM. Sus pruebas tendrán fugas de memoria - para combatir eso, considere editar manualmente el valor de experimentalVmWorkerMemoryLimit.

WARNING

Ejecutar código en un sandbox tiene algunas ventajas (pruebas más rápidas), pero también viene con una serie de desventajas.

Los globales dentro de los módulos nativos, como (fs, path, etc.), difieren de los globales presentes en su entorno de prueba. Como resultado, cualquier error lanzado por estos módulos nativos hará referencia a un constructor de Error diferente en comparación con el utilizado en su código:

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

La importación de módulos ES los almacena en caché indefinidamente, lo que introduce fugas de memoria si tiene muchos contextos (archivos de prueba). No hay ninguna API en Node.js que borre esa caché.
El acceso a los globales tarda más en un entorno sandbox.

Por favor, tenga en cuenta estos problemas al utilizar esta opción. El equipo de Vitest no puede solucionar ninguno de los problemas de nuestro lado.

experimentalVmWorkerMemoryLimit

Tipo: string | number
CLI: --experimentalVmWorkerMemoryLimit, --experimental-vm-worker-memory-limit
Predeterminado: 1 / Número de núcleos de CPU
Versión: Desde Vitest 0.34.0

Especifica el límite de memoria para los workers antes de que se reciclen. Este valor depende en gran medida de su entorno, por lo que es mejor especificarlo manualmente en lugar de confiar en el valor predeterminado.

Esta opción solo afecta a los workers que ejecutan pruebas en VM context.

TIP

La implementación se basa en workerIdleMemoryLimit de Jest.

El límite se puede especificar de varias maneras diferentes y, sea cual sea el resultado, se utiliza Math.floor para convertirlo en un valor entero:

<= 1 - Se asume que el valor es un porcentaje de la memoria del sistema. Por lo tanto, 0.5 establece el límite de memoria del worker a la mitad de la memoria total del sistema.
\> 1 - Se asume que es un valor de byte fijo. Debido a la regla anterior, si quisiera un valor de 1 byte (no sé por qué) podría usar 1.1.
Con unidades
- 50% - Como arriba, un porcentaje de la memoria total del sistema.
- 100KB, 65MB, etc. - Con unidades para denotar un límite de memoria fijo.
  - K / KB - Kilobytes (x1000)
  - KiB - Kibibytes (×1024)
  - M / MB - Megabytes
  - MiB - Mebibytes
  - G / GB - Gigabytes
  - GiB - Gibibytes

WARNING

El límite de memoria basado en porcentaje no funciona en los workers de Linux CircleCI debido a que se informa una memoria del sistema incorrecta.

threads

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

Habilita el multihilo utilizando tinypool (un fork ligero de Piscina). Antes de Vitest 0.29.0, Vitest todavía ejecutaba pruebas dentro de un hilo de worker, incluso si esta opción estaba deshabilitada. Desde 0.29.0, si esta opción está deshabilitada, Vitest utiliza child_process para generar un proceso para ejecutar pruebas dentro, lo que significa que puede utilizar process.chdir y otras API que no estaban disponibles dentro de los workers. Si desea volver al comportamiento anterior, utilice la opción --single-thread en su lugar.

Deshabilitar esta opción hace que todas las pruebas se ejecuten dentro de múltiples procesos hijos.

singleThread

Tipo: boolean
Predeterminado: false
Versión: Desde Vitest 0.29.0

Ejecuta todas las pruebas con el mismo entorno dentro de un solo hilo de worker. Esto deshabilitará el aislamiento de módulos incorporado (su código fuente o el código en línea todavía se volverá a evaluar para cada prueba), pero puede mejorar el rendimiento de las pruebas. Antes de Vitest 0.29.0, esto era equivalente a usar --no-threads.

WARNING

Aunque esta opción forzará a que las pruebas se ejecuten una tras otra, esta opción es diferente de --runInBand de Jest. Vitest utiliza workers no solo para ejecutar pruebas en paralelo, sino también para proporcionar aislamiento. Al deshabilitar esta opción, sus pruebas se ejecutarán secuencialmente, pero en el mismo contexto global, por lo que debe proporcionar el aislamiento usted mismo.

Esto podría causar diversos problemas si confía en el estado global (lo cual es común en los frameworks frontend) o si su código depende de que el entorno se defina de manera separada para cada prueba. Pero puede ser un aumento de velocidad para sus pruebas (hasta 3 veces más rápido), que no necesariamente dependen del estado global o pueden evitarlo fácilmente.

maxThreads*

Tipo: number
Predeterminado: CPUs disponibles

Número máximo de hilos. También puede utilizar la variable de entorno VITEST_MAX_THREADS.

minThreads*

Tipo: number
Predeterminado: CPUs disponibles

Número mínimo de hilos. También puede utilizar la variable de entorno VITEST_MIN_THREADS.

useAtomics*

Tipo: boolean
Predeterminado: false
Versión: Desde Vitest 0.28.3

Utiliza Atomics para sincronizar hilos.

Esto puede mejorar el rendimiento en algunos casos, pero podría causar un segmentation fault en versiones antiguas de Node.

testTimeout

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

Tiempo de espera predeterminado de una prueba en milisegundos.

hookTimeout

Tipo: number
Predeterminado: 10000

Tiempo de espera predeterminado de un hook en milisegundos.

teardownTimeout*

Tipo: number
Predeterminado: 10000

Tiempo de espera predeterminado para esperar el cierre cuando Vitest se apaga, en milisegundos.

silent*

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

Silencia la salida de la consola de las pruebas.

setupFiles

Tipo: string | string[]

Ruta a los archivos de configuración. Se ejecutarán antes de cada archivo de prueba.

INFO

Cambiar los archivos de configuración activará la repetición de todas las pruebas.

Puede utilizar process.env.VITEST_POOL_ID (cadena similar a un entero) en el interior para distinguir entre hilos (siempre será '1', si se ejecuta con threads: false).

TIP

Tenga en cuenta que si está ejecutando --threads=false, este archivo de configuración se ejecutará en el mismo ámbito global varias veces. Esto significa que está accediendo al mismo objeto global antes de cada prueba, así que asegúrese de no estar haciendo lo mismo más de lo que necesita.

Por ejemplo, puede confiar en una variable global:

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

Ruta a los archivos de configuración global, relativa a la raíz del proyecto.

Un archivo de configuración global puede exportar funciones nombradas setup y teardown o una función default que devuelve una función de teardown (ejemplo).

INFO

Es posible tener múltiples archivos globalSetup. setup y teardown se ejecutan secuencialmente con teardown en orden inverso.

WARNING

Tenga en cuenta que la configuración global se ejecuta en un ámbito global diferente, por lo que sus pruebas no tienen acceso a las variables definidas aquí.

watchExclude*

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

Patrón glob de rutas de archivo que se ignorarán para evitar que se active la repetición del watch.

forceRerunTriggers*

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

Patrón glob de rutas de archivo que activarán la repetición de toda la suite. Cuando se combina con el argumento --changed, ejecutará toda la suite de pruebas si se encuentra el disparador en el diff de git.

Útil si está probando llamadas a comandos CLI, porque Vite no puede construir un gráfico de módulos:

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

TIP

Asegúrese de que sus archivos no estén excluidos por watchExclude.

isolate

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

Aísla el entorno de cada archivo de prueba. No funciona si deshabilitas --threads.

Esta opción no afecta a experimentalVmThreads.

coverage*

Puedes usar v8, istanbul o una solución de cobertura personalizada para la recopilación de la cobertura.

Puedes proporcionar opciones de cobertura a la CLI utilizando la notación de puntos:

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

WARNING

Si utilizas opciones de cobertura con la notación de puntos, recuerda especificar --coverage.enabled. No proporciones una única opción --coverage en ese caso.

coverage.provider

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

Utiliza provider para seleccionar la herramienta de recopilación de la cobertura.

coverage.enabled

Tipo: boolean
Predeterminado: false
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.enabled, --coverage.enabled=false

Habilita la recopilación de la cobertura. Se puede anular utilizando la opción de la CLI --coverage.

coverage.include

Tipo: string[]
Predeterminado: ['**']
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.include=<ruta>, --coverage.include=<ruta1> --coverage.include=<ruta2>

Lista de archivos incluidos en el cálculo de la cobertura, utilizando patrones glob.

coverage.extension

Tipo: string | string[]
Predeterminado: ['.js', '.cjs', '.mjs', '.ts', '.mts', '.cts', '.tsx', '.jsx', '.vue', '.svelte']
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.extension=<extensión>, --coverage.extension=<extensión1> --coverage.extension=<extensión2>

coverage.exclude

Tipo: string[]
Predeterminado:

[
  '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}',
];

Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.exclude=<ruta>, --coverage.exclude=<ruta1> --coverage.exclude=<ruta2>

Lista de archivos excluidos del cálculo de la cobertura, utilizando patrones glob.

coverage.all

Tipo: boolean
Predeterminado: false
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.all, --coverage.all=false

Indica si se deben incluir todos los archivos en el informe, incluso aquellos que no tienen pruebas asociadas.

coverage.clean

Tipo: boolean
Predeterminado: true
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.clean, --coverage.clean=false

Elimina los resultados de la cobertura anteriores antes de ejecutar las pruebas.

coverage.cleanOnRerun

Tipo: boolean
Predeterminado: true
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.cleanOnRerun, --coverage.cleanOnRerun=false

Elimina el informe de cobertura al volver a ejecutar las pruebas en modo de vigilancia.

coverage.reportsDirectory

Tipo: string
Predeterminado: './coverage'
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.reportsDirectory=<ruta>

Directorio donde se guardará el informe de cobertura.

coverage.reporter

Tipo: string | string[] | [string, {}][]
Predeterminado: ['text', 'html', 'clover', 'json']
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.reporter=<reportero>, --coverage.reporter=<reportero1> --coverage.reporter=<reportero2>

Formatos de informe de cobertura que se utilizarán. Consulta la documentación de Istanbul para obtener una lista detallada de todos los formatos disponibles. Consulta @types/istanbul-reporter para obtener detalles sobre las opciones específicas de cada formato.

El reportero puede definirse de tres maneras diferentes:

Un solo reportero: { reporter: 'html' }
Múltiples reporteros sin opciones: { reporter: ['html', 'json'] }

Uno o varios reporteros con opciones específicas:

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

Desde Vitest 0.31.0, puedes revisar tu informe de cobertura en la interfaz de usuario de Vitest: consulta Cobertura en la interfaz de usuario de Vitest para obtener más detalles.

coverage.reportOnFailure

Tipo: boolean
Predeterminado: false (desde Vitest 0.34.0)
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.reportOnFailure, --coverage.reportOnFailure=false
Versión: Desde Vitest 0.31.2

Genera el informe de cobertura incluso si las pruebas fallan.

coverage.allowExternal

Tipo: boolean
Predeterminado: false
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.allowExternal, --coverage.allowExternal=false

Recopila la cobertura de los archivos que están fuera del root del proyecto.

coverage.skipFull

Tipo: boolean
Predeterminado: false
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.skipFull, --coverage.skipFull=false

Omite los archivos con una cobertura del 100% en sentencias, ramas y funciones.

coverage.perFile

Tipo: boolean
Predeterminado: false
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.perFile, --coverage.perFile=false

Comprueba los umbrales de cobertura por archivo. Consulta lines, functions, branches y statements para los umbrales específicos.

coverage.thresholdAutoUpdate

Tipo: boolean
Predeterminado: false
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.thresholdAutoUpdate=<boolean>

Actualiza los valores de umbral de lines (líneas), functions (funciones), branches (ramas) y statements (sentencias) en el archivo de configuración cuando la cobertura actual supera los umbrales configurados. Esta opción ayuda a mantener los umbrales actualizados a medida que mejora la cobertura.

coverage.lines

Tipo: number
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.lines=<número>

Umbral para la cobertura de líneas. Consulta la documentación de Istanbul para obtener más información.

coverage.functions

Tipo: number
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.functions=<número>

Umbral para la cobertura de funciones. Consulta la documentación de Istanbul para obtener más información.

coverage.branches

Tipo: number
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.branches=<número>

Umbral para la cobertura de ramas. Consulta la documentación de Istanbul para obtener más información.

coverage.statements

Tipo: number
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.statements=<número>

Umbral para la cobertura de sentencias. Consulta la documentación de Istanbul para obtener más información.

coverage.100

Tipo: boolean
Predeterminado: false
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.100, --coverage.100=false

Atajo para --coverage.lines 100 --coverage.functions 100 --coverage.branches 100 --coverage.statements 100.

coverage.ignoreClassMethods

Tipo: string[]
Predeterminado: []
Disponible para proveedores: 'istanbul'
CLI: --coverage.ignoreClassMethods=<método>

Define un array con los nombres de los métodos de clase que se ignorarán en el cálculo de la cobertura. Consulta la documentación de Istanbul para obtener más información.

coverage.watermarks

Tipo:

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

Predeterminado:

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

Disponible para proveedores: 'v8' | 'istanbul'

Marcas de agua para sentencias, líneas, ramas y funciones. Consulta la documentación de Istanbul para obtener más información.

coverage.customProviderModule

Tipo: string
Disponible para proveedores: 'custom'
CLI: --coverage.customProviderModule=<ruta o nombre del módulo>

Especifica el nombre del módulo o la ruta al módulo del proveedor de cobertura personalizado. Consulta Guía - Proveedor de cobertura personalizado para obtener más información.

testNamePattern*

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

Ejecuta las pruebas cuyos nombres completos coincidan con el patrón especificado. Si añades OnlyRunThis a esta propiedad, las pruebas que no incluyan la palabra OnlyRunThis en su nombre se omitirán.

import { expect, test } from 'vitest';

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

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

open*

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

Abre la interfaz de usuario de Vitest (WIP).

api

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

Habilita la escucha en un puerto y sirve la API. Cuando se establece en true, el puerto predeterminado es 51204.

browser

Tipo: { enabled?, name?, provider?, headless?, api?, slowHijackESM? }
Predeterminado: { enabled: false, headless: process.env.CI, api: 63315 }
Versión: Desde Vitest 0.29.4
CLI: --browser, --browser=<name>, --browser.name=chrome --browser.headless

Ejecuta las pruebas de Vitest en un navegador. Utilizamos WebdriverIO para ejecutar las pruebas de forma predeterminada, pero se puede configurar con la opción browser.provider.

NOTA

Lee más sobre las pruebas en un navegador real en la página de la guía.

WARNING

Esta es una característica experimental. Los cambios importantes podrían no seguir semver, por favor, ancla la versión de Vitest cuando la uses.

browser.enabled

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

Habilita la ejecución de todas las pruebas dentro de un navegador de forma predeterminada. Se puede anular con la opción poolMatchGlobs.

browser.name

Tipo: string
CLI: --browser=safari

Ejecuta todas las pruebas en un navegador específico. Las opciones posibles varían según el proveedor:

webdriverio: firefox, chrome, edge, safari
playwright: firefox, webkit, chromium
personalizado: cualquier texto que se pasará al proveedor

browser.headless

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

Ejecuta el navegador en modo headless (sin interfaz gráfica). Si estás ejecutando Vitest en CI, se habilitará de forma predeterminada.

browser.api

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

Configura las opciones para el servidor Vite que sirve el código en el navegador. No afecta a la opción test.api.

browser.provider

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

Ruta del proveedor que se utilizará al ejecutar las pruebas en el navegador. Vitest proporciona dos proveedores: webdriverio (predeterminado) y playwright. Los proveedores personalizados deben exportarse utilizando la exportación default y tener la siguiente estructura:

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

Esta es una API avanzada para los autores de la biblioteca. Si solo necesitas ejecutar pruebas en un navegador, utiliza la opción browser.

browser.slowHijackESM

Tipo: boolean
Predeterminado: true
Versión: Desde Vitest 0.31.0

Cuando se ejecutan pruebas en Node.js, Vitest puede usar su propia resolución de módulos para simularlos fácilmente con la sintaxis vi.mock. Sin embargo, replicar la resolución de módulos ES en el navegador no es tan sencillo, por lo que es necesario transformar los archivos fuente antes de que el navegador pueda consumirlos.

Esta opción no tiene ningún efecto en las pruebas que se ejecutan en Node.js.

Esta opción está activada por defecto al ejecutarse en el navegador. Si no utiliza vi.spyOn para espiar módulos ES ni vi.mock, puede deshabilitar esta opción para obtener una ligera mejora en el rendimiento.

clearMocks

Tipo: boolean
Predeterminado: false

Ejecutará .mockClear() en todos los espías antes de cada prueba. Esto limpiará el historial de mocks, pero no restablecerá su implementación a la predeterminada.

mockReset

Tipo: boolean
Predeterminado: false

Ejecutará .mockReset() en todos los espías antes de cada prueba. Esto limpiará el historial de mocks y restablecerá su implementación a una función vacía (que devolverá undefined).

restoreMocks

Tipo: boolean
Predeterminado: false

Ejecutará .mockRestore() en todos los espías antes de cada prueba. Esto limpiará el historial de mocks y restablecerá su implementación a la original.

unstubEnvs

Tipo: boolean
Predeterminado: false
Versión: Desde Vitest 0.26.0

Llamará a vi.unstubAllEnvs antes de cada prueba.

unstubGlobals

Tipo: boolean
Predeterminado: false
Versión: Desde Vitest 0.26.0

Llamará a vi.unstubAllGlobals antes de cada prueba.

testTransformMode

Tipo: { web?, ssr? }
Versión: Desde Vitest 0.34.0

Determina el método de transformación para todos los módulos importados en una prueba que coincida con el patrón glob. De forma predeterminada, se basa en el entorno. Por ejemplo, las pruebas con el entorno JSDOM procesarán todos los archivos con el indicador ssr: false, y las pruebas con el entorno Node procesarán todos los módulos con ssr: true.

testTransformMode.ssr

Tipo: string[]
Predeterminado: []

Utiliza la canalización de transformación SSR para todos los módulos en las pruebas especificadas.
Los plugins de Vite recibirán la bandera ssr: true al procesar esos archivos.

testTransformMode.web

Tipo: string[]
Predeterminado: []

Realiza primero una canalización de transformación normal (para el navegador) y luego realiza una reescritura SSR para ejecutar el código en Node.
Los plugins de Vite recibirán la bandera ssr: false al procesar esos archivos.

snapshotFormat*

Tipo: PrettyFormatOptions

Opciones de formato para las instantáneas (snapshots). Estas opciones se pasan a pretty-format.

resolveSnapshotPath*

Tipo: (testPath: string, snapExtension: string) => string
Predeterminado: almacena los archivos de instantáneas en el directorio __snapshots__

Sobrescribe la ruta predeterminada de las instantáneas. Por ejemplo, para almacenar instantáneas junto a los archivos de prueba:

import { defineConfig } from 'vitest/config';

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

allowOnly

Tipo: boolean
Predeterminado: false
CLI: --allowOnly, --allowOnly=false

Permite la ejecución de pruebas y suites marcadas como 'only'.

dangerouslyIgnoreUnhandledErrors*

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

Ignora cualquier error no controlado que ocurra.

passWithNoTests*

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

Vitest no fallará si no se encuentran pruebas.

logHeapUsage

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

Muestra el uso de heap después de cada prueba. Útil para depurar fugas de memoria.

css

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

Configura si se debe procesar el CSS. Cuando se excluyen, los archivos CSS se reemplazan con cadenas vacías para evitar el procesamiento posterior. Los CSS Modules devolverán un proxy para no afectar al tiempo de ejecución.

css.include

Tipo: RegExp | RegExp[]
Predeterminado: []

Patrón RegExp para los archivos que deben devolver CSS real y que serán procesados por la canalización de Vite.

TIP

Para procesar todos los archivos CSS, use /.+/.

css.exclude

Tipo: RegExp | RegExp[]
Predeterminado: []

Patrón RegExp para los archivos que devolverán un archivo CSS vacío.

css.modules

Tipo: { classNameStrategy? }
Predeterminado: {}

css.modules.classNameStrategy

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

Si decide procesar archivos CSS, puede configurar si los nombres de clase dentro de los módulos CSS deben tener un ámbito (scoped). Puede elegir una de las opciones:

stable: los nombres de clase se generarán como _${name}_${hashedFilename}, lo que significa que la clase generada permanecerá igual si el contenido CSS se modifica, pero cambiará si se modifica el nombre del archivo o si el archivo se mueve a otra carpeta. Esta configuración es útil si usa la función de instantáneas.
scoped: los nombres de clase se generarán como de costumbre, respetando el método css.modules.generateScopeName, si tiene uno y el procesamiento CSS está habilitado. De forma predeterminada, el nombre de archivo se generará como _${name}_${hash}, donde el hash incluye el nombre de archivo y el contenido del archivo.
non-scoped: los nombres de clase no tendrán hash.

WARNING

De forma predeterminada, Vitest exporta un proxy, omitiendo el procesamiento de módulos CSS. Si confía en las propiedades CSS en sus clases, debe habilitar el procesamiento CSS usando la opción include.

maxConcurrency

Tipo: number
Predeterminado: 5

El número de pruebas que se pueden ejecutar simultáneamente marcadas con test.concurrent.

Las pruebas que superen este límite se pondrán en cola para ejecutarse cuando haya un espacio disponible.

cache*

Tipo: false | { dir? }

Opciones para configurar la política de caché de Vitest. Por el momento, Vitest almacena en caché los resultados de las pruebas para ejecutar primero las pruebas más largas y fallidas.

cache.dir

Tipo: string
Predeterminado: node_modules/.vitest

Ruta al directorio de caché.

sequence

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

Opciones para cómo se deben ordenar las pruebas.

Puede proporcionar opciones de secuencia a la CLI con notación de puntos:

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

sequence.sequencer*

Tipo: TestSequencerConstructor
Predeterminado: BaseSequencer

Una clase personalizada que define métodos para particionar (sharding) y ordenar. Puede extender BaseSequencer desde vitest/node si solo necesita redefinir uno de los métodos sort y shard, pero ambos deben existir.

La fragmentación se realiza antes de la ordenación, y solo si se proporciona la opción --shard.

sequence.shuffle

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

Si desea que las pruebas se ejecuten de forma aleatoria, puede habilitar esta opción o usar el argumento de la CLI --sequence.shuffle.

Vitest generalmente usa la caché para ordenar las pruebas, por lo que las pruebas de larga duración comienzan antes; esto hace que las pruebas se ejecuten más rápido. Si sus pruebas se ejecutan en orden aleatorio, perderá esta mejora de rendimiento, pero puede ser útil para rastrear las pruebas que dependen accidentalmente de otra ejecución anterior.

sequence.concurrent

Tipo: boolean
Predeterminado: false
CLI: --sequence.concurrent, --sequence.concurrent=false
Versión: Desde Vitest 0.32.2

Si desea que las pruebas se ejecuten de forma concurrente, puede habilitar esta opción o usar el argumento de la CLI --sequence.concurrent.

sequence.seed*

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

Establece la semilla de aleatorización si las pruebas se ejecutan en orden aleatorio.

sequence.hooks

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

Cambia el orden en que se ejecutan los hooks.

stack ordenará los hooks "after" en orden inverso; los hooks "before" se ejecutarán en el orden en que se definieron.
list ordenará todos los hooks en el orden en que se definen.
parallel ejecutará los hooks en un solo grupo en paralelo (los hooks en las suites principales seguirán ejecutándose antes que los hooks de la suite actual).

sequence.setupFiles

Tipo: 'list' | 'parallel'
Predeterminado: 'parallel'
CLI: --sequence.setupFiles=<value>
Versión: Desde Vitest 0.29.3

Cambia el orden en que se ejecutan los archivos de configuración.

list ejecutará los archivos de configuración en el orden en que se definen.
parallel ejecutará los archivos de configuración en paralelo.

typecheck

Opciones para configurar el entorno de prueba de verificación de tipos.

typecheck.checker

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

Qué herramienta usar para la verificación de tipos. Vitest generará un proceso con ciertos parámetros para facilitar el análisis, según el tipo. El verificador debe implementar el mismo formato de salida que tsc.

Debe tener un paquete instalado para usar el verificador de tipos:

tsc requiere el paquete typescript
vue-tsc requiere el paquete vue-tsc

También puede pasar una ruta a un binario personalizado o un nombre de comando que produzca la misma salida que tsc --noEmit --pretty false.

typecheck.include

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

Patrón glob para archivos que deben tratarse como archivos de prueba.

typecheck.exclude

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

Patrón glob para archivos que no deben tratarse como archivos de prueba.

typecheck.allowJs

Tipo: boolean
Predeterminado: false

Verifica los archivos JS que tienen el comentario @ts-check. Si lo tiene habilitado en tsconfig, esto no lo sobrescribirá.

typecheck.ignoreSourceErrors

Tipo: boolean
Predeterminado: false

No falla si Vitest encuentra errores fuera de los archivos de prueba. Esto no mostrará errores que no sean de prueba.

De forma predeterminada, si Vitest encuentra un error de origen, fallará la suite de pruebas.

typecheck.tsconfig

Tipo: string
Predeterminado: intenta encontrar el tsconfig.json más cercano

Ruta a tsconfig personalizado, relativa a la raíz del proyecto.

slowTestThreshold*

Tipo: number
Predeterminado: 300

El número de milisegundos después del cual una prueba se considera lenta y se informa como tal en los resultados.

chaiConfig

Tipo: { includeStack?, showDiff?, truncateThreshold? }
Predeterminado: { includeStack: false, showDiff: true, truncateThreshold: 40 }
Versión: Desde Vitest 0.30.0

Equivalente a la configuración de Chai.

chaiConfig.includeStack

Tipo: boolean
Predeterminado: false

Determina si la traza de la pila se incluye en el mensaje de error de Assertion. El valor predeterminado de false suprime la traza de la pila en el mensaje de error.

chaiConfig.showDiff

Tipo: boolean
Predeterminado: true

Determina si el indicador showDiff se debe incluir en los AssertionErrors lanzados. false siempre será false; true será verdadero cuando la aserción haya solicitado que se muestre una diferencia.

chaiConfig.truncateThreshold

Tipo: number
Predeterminado: 40

Establece el umbral de longitud para los valores reales y esperados en los errores de aserción. Si se excede este umbral, por ejemplo, para estructuras de datos grandes, el valor se reemplaza con algo como [ Array(3) ] o { Object (prop1, prop2) }. Configúrelo en 0 si quiere desactivar el truncamiento por completo.

Esta opción de configuración afecta el truncamiento de valores en los títulos de test.each y dentro del mensaje de error de aserción.

bail

Tipo: number
Predeterminado: 0
CLI: --bail=<value>
Versión: Desde Vitest 0.31.0

Detiene la ejecución de las pruebas cuando ha fallado el número especificado de pruebas.

Esto puede no ser deseable en compilaciones de CI, donde solo se busca que sean 100% exitosas. En tales casos, es preferible detener la ejecución de las pruebas lo antes posible al ocurrir fallas. La opción bail se puede usar para acelerar las ejecuciones de CI al evitar que ejecute más pruebas cuando se han producido fallas.

retry

Tipo: number
Predeterminado: 0
CLI: --retry=<value>
Versión: Desde Vitest 0.32.3

Reintenta la prueba un número específico de veces si falla.

onConsoleLog

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

Manejador personalizado para console.log en las pruebas. Si devuelve false, Vitest no imprimirá el registro en la consola.

Puede ser útil para filtrar los logs de bibliotecas de terceros.

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>
Versión: Desde Vitest 0.34.5

Ruta a un archivo de configuración de diff que se utilizará para generar la interfaz de diff. Útil si desea personalizar la visualización de 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',
  },
});

Configuración de Vitest ​

Configuración ​

Opciones ​

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 ​

coverage* ​

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 ​

Configuración de Vitest

Configuración

Opciones

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

coverage*

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