Configuración de Vitest

Para crear un archivo de configuración de Vitest, consulta la guía. Asegúrate de comprender cómo se resuelve la configuración de Vitest antes de continuar.

WARNING

Todas las opciones enumeradas aquí se encuentran dentro de la propiedad test en la configuración:

export default defineConfig({
  test: {
    exclude: [],
  },
});

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.

Todas las opciones de configuración que no son compatibles dentro de un proyecto de espacio de trabajo tienen el símbolo * junto a ellas.

include

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

Lista de patrones glob que coinciden con tus archivos de 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.*']
CLI: vitest --exclude "**/excluded-file"

Lista de patrones glob que se deben excluir de tus archivos de prueba.

WARNING

Esta opción no afecta a la cobertura. Si necesitas eliminar ciertos archivos del informe de cobertura, usa coverage.exclude.

Esta es la única opción que no anula tu configuración si la proporcionas con un flag de la CLI. Todos los patrones glob agregados a través del flag --exclude se añadirán a la opción exclude de la configuración.

includeSource

Tipo: string[]
Por defecto: []

Incluye patrones glob para archivos de prueba en el código fuente.

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

server 0.34.0+

Tipo: { sourcemap?, deps?, ... }

Opciones del servidor Vite-Node.

server.sourcemap

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

Inyecta el mapa de origen en línea en los módulos.

server.debug

Tipo: { dumpModules?, loadDumppedModules? }

Opciones del depurador de Vite-Node.

server.debug.dumpModules

Tipo: boolean | string

Guarda el módulo transformado en el sistema de archivos. Pasar una cadena lo guardará en la ruta especificada.

server.debug.loadDumppedModules

Tipo: boolean

Carga el módulo guardado desde el sistema de archivos si existe. Útil para depurar modificando el resultado guardado en el sistema de archivos.

server.deps

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

Gestión de la resolución de dependencias.

server.deps.external

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

Externalizar significa que Vite pasará el paquete directamente a Node. Las dependencias externalizadas no se procesarán con los transformadores y resolutores de Vite, por lo que no admiten HMR al recargar. Por defecto, todos los paquetes dentro de node_modules están externalizados.

Estas opciones aceptan nombres de paquetes tal como aparecen en node_modules o como se especifican en 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. En esencia, Vitest siempre comprueba la ruta del archivo, no el nombre del paquete.

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

server.deps.inline

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

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

Si es true, todas las dependencias se incluirán. Todas las dependencias especificadas en ssr.noExternal se incluirán por defecto.

server.deps.fallbackCJS

Tipo boolean
Por defecto: false

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

Esto podría causar una inconsistencia 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 archivos de caché.

deps

Tipo: { optimizer?, ... }

Gestión de la resolución de dependencias.

deps.optimizer 0.34.0+

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

Activa la optimización de dependencias. Si tienes muchas pruebas, esto podría mejorar su rendimiento. Antes de Vitest 0.34.0, se llamaba deps.experimentalOptimizer.

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

Importar paquetes con un gran número de importaciones es costoso. Al agruparlos en un archivo, podemos ahorrar mucho tiempo.
Importar bibliotecas de UI es costoso porque no están diseñadas para ejecutarse dentro de Node.js.
Tu configuración de alias ahora se aplica a los paquetes agrupados.
El código de tus pruebas se ejecuta 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 se agrupan (algunos plugins completan esto automáticamente, como Svelte). Puedes encontrar más información sobre las opciones disponibles en la documentación de Vite (Vitest no admite las opciones disable y noDiscovery). Por defecto, Vitest usa optimizer.web para los entornos jsdom y happy-dom, y optimizer.ssr para los entornos node y edge, pero es configurable 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 editar tu código de node_modules para la depuración, ya que el código se encuentra 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: false desde Vitest 1.3.0

Activa la optimización de dependencias.

WARNING

Esta opción solo funciona con Vite 4.3.2 y superior.

deps.web 0.34.2+

Tipo: { transformAssets?, ... }

Opciones que se aplican a los archivos externos cuando el modo de transformación se establece en web. Por defecto, 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 se externalizan, pero estas opciones también afectan a los archivos en server.deps.external.

deps.web.transformAssets

Tipo: boolean
Por defecto: true

Determina si Vitest debe procesar los archivos de recursos (como .png, .svg, .jpg, etc.) y resolverlos como lo hace Vite en el navegador.

Este módulo tendrá una exportación por defecto que será la ruta al recurso, a menos que se especifique una consulta.

WARNING

Por el momento, esta opción solo funciona con los pools vmThreads y vmForks.

deps.web.transformCss

Tipo: boolean
Por defecto: true

Determina si Vitest debe procesar los archivos CSS (como .css, .scss, .sass, etc.) y resolverlos como lo hace Vite en el navegador.

Si los archivos CSS están desactivados mediante la opción css, esta opción simplemente evitará que se muestren los errores ERR_UNKNOWN_FILE_EXTENSION.

WARNING

Por el momento, esta opción solo funciona con los pools vmThreads y vmForks.

deps.web.transformGlobPattern

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

Patrón de expresión regular para coincidir con los archivos externos que deben transformarse.

Por defecto, los archivos dentro de node_modules se externalizan y no se transforman, a menos que sea CSS o un recurso, y la opción correspondiente no esté deshabilitada.

WARNING

Por el momento, esta opción solo funciona con los pools vmThreads y vmForks.

deps.interopDefault

Tipo: boolean
Por defecto: true

Interpreta la exportación por defecto de los módulos CJS como exportaciones con nombre. Algunas dependencias solo incluyen módulos CJS y no utilizan exportaciones con nombre que Node.js puede analizar estáticamente cuando se importa un paquete utilizando 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 detectar el error antes de ejecutar el código, por lo que es 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

Por defecto, Vitest asume que estás utilizando un bundler para evitar este problema y no mostrará el error, pero puedes desactivar este comportamiento manualmente si tu código no se procesa.

deps.moduleDirectories

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

Lista de directorios que deben tratarse como directorios de módulos. Esta opción de configuración afecta al comportamiento de vi.mock: cuando no se proporciona una función factory y la ruta del módulo 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. Por defecto, Vitest importa módulos externos con Node.js nativo omitiendo el paso de transformación de Vite.

Definir esta opción sobrescribirá el valor predeterminado. Si quieres seguir buscando paquetes en node_modules, inclúyelo junto con las demás opciones:

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 runner de pruebas personalizado. Esta es una característica avanzada y se recomienda usarla con runners de bibliotecas personalizadas. Puedes leer más sobre esto en la documentación.

benchmark

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

Opciones que se utilizan 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 benchmarks.

benchmark.exclude

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

Patrones glob para excluir archivos de prueba de benchmarks.

benchmark.includeSource

Tipo: string[]
Por defecto: []

Incluye patrones glob para 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 dentro de ellos.

benchmark.reporters

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

Reporter personalizado para la salida. Puede contener uno o más nombres de informes integrados, instancias de reporters y/o rutas a reporters personalizados.

benchmark.outputFile

Tipo: string | Record<string, string>

Escribe los resultados del benchmark en un archivo si también se especifica la opción --reporter=json. Al proporcionar un objeto en lugar 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.

benchmark.outputJson 1.6.0+

Tipo: string | undefined
Por defecto: undefined

Una ruta de archivo para almacenar el resultado del benchmark, que se podrá utilizar más adelante con la opción --compare.

Por ejemplo:

# guarda el resultado de la rama principal
git checkout main
vitest bench --outputJson main.json

# cambia una rama y compara con la principal
git checkout feature
vitest bench --compare main.json

benchmark.compare 1.6.0+

Tipo: string | undefined
Por defecto: undefined

Una ruta de archivo a un resultado de benchmark anterior para comparar con las ejecuciones actuales.

alias

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

Define alias personalizados para su uso dentro de las pruebas. Se fusionarán con los alias de resolve.alias.

WARNING

Vitest utiliza primitivas Vite SSR para ejecutar las pruebas, lo que implica ciertas limitaciones.

Los alias solo afectan a los módulos importados directamente con la palabra clave import desde un módulo incluido (todo el código fuente se incluye por defecto).
Vitest no admite alias de llamadas require.
Si estás definiendo un alias para una dependencia externa (por ejemplo, react -> preact), es posible que quieras definir el alias directamente en los paquetes de node_modules para que funcione también con las dependencias externalizadas. Tanto Yarn como pnpm admiten alias a través del prefijo npm:.

globals

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

Por defecto, vitest no proporciona APIs globales para fomentar la claridad. Si prefieres utilizar las APIs de forma global como en Jest, puedes pasar la opción --globals a la CLI o añadir globals: true en la configuración.

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

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

Para que TypeScript reconozca 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 utilizando unplugin-auto-import en tu proyecto, puedes usarlo directamente para importar automáticamente estas APIs.

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

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

environment

Tipo: 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime' | string
Valor predeterminado: 'node'
CLI: --environment=<env>

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

Puedes especificar un entorno diferente para todas las pruebas de un archivo agregando un bloque de comentarios @vitest-environment en la parte superior del archivo:

Estilo Docblock:

/**
 * @vitest-environment jsdom
 */

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

Estilo de comentario:

// @vitest-environment happy-dom

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

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

/**
 * @jest-environment jsdom
 */

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

Si ejecutas Vitest con la opción --isolate=false, las pruebas se ejecutarán en este orden: node, jsdom, happy-dom, edge-runtime, custom environments (entornos personalizados). Esto significa que las pruebas con el mismo entorno se agrupan y se ejecutan secuencialmente.

A partir de la versión 0.23.0, también puedes definir un entorno personalizado. Cuando se utiliza un entorno no predefinido, Vitest intentará cargar el paquete vitest-environment-${name}. Este paquete debe exportar un objeto con la estructura 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 del punto de entrada vitest/environments, en caso de que solo quieras extenderlo. Puedes leer más sobre la extensión de entornos en nuestra guía.

TIP

Desde Vitest 1.3.0, el entorno jsdom expone la variable global jsdom igual a la instancia actual de JSDOM. Si quieres que TypeScript la reconozca, puedes agregar vitest/jsdom a tu tsconfig.json cuando uses este entorno:

json

{
  "compilerOptions": {
    "types": ["vitest/jsdom"]
  }
}

environmentOptions

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

Estas opciones se pasan al método setup del environment actual. De forma predeterminada, solo puedes configurar las opciones de JSDOM si lo estás utilizando como tu entorno de prueba.

environmentMatchGlobs

Tipo: [string, EnvironmentName][]
Valor predeterminado: []

Asigna automáticamente el entorno según 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 0.29.4+

Tipo: [string, 'threads' | 'forks' | 'vmThreads' | 'vmForks' | 'typescript'][]
Valor predeterminado: []

Asigna automáticamente el grupo (pool) en el que se ejecutarán las pruebas según 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 habilitara `--pool=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 según las opciones "browser.enabled" y "threads", si no especificaste otros globs
      // ...
    ],
  },
});

update*

Tipo: boolean
Valor predeterminado: false
CLI: -u, --update, --update=false

Actualiza los archivos de instantáneas (snapshots). Esto actualizará todas las instantáneas modificadas y eliminará las obsoletas.

watch*

Tipo: boolean
Valor predeterminado: !process.env.CI
CLI: -w, --watch, --watch=false

Activa el modo de observación (watch mode).

root

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

Directorio raíz del proyecto.

reporters*

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

Reportes personalizados para la salida. Los reporters pueden ser una instancia de Reporter, una cadena para seleccionar reporters integrados o una ruta a una implementación personalizada (por ejemplo, './path/to/reporter.ts', '@scope/reporter').

outputFile*

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

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

pool* 1.0.0+

Tipo: 'threads' | 'forks' | 'vmThreads' | 'vmForks'
Valor predeterminado: 'threads'
CLI: --pool=threads

Grupo (pool) utilizado para ejecutar las pruebas.

threads*

Activa el multihilo utilizando tinypool (una bifurcación ligera de Piscina). Cuando se utilizan hilos, no se pueden utilizar las API relacionadas con el proceso, como process.chdir(). Algunas bibliotecas escritas en lenguajes nativos, como Prisma, bcrypt y canvas, tienen problemas al ejecutarse en varios hilos y provocan fallos de segmentación. En estos casos, se recomienda utilizar el grupo forks en su lugar.

forks*

Similar al grupo threads, pero utiliza child_process en lugar de worker_threads a través de tinypool. La comunicación entre las pruebas y el proceso principal no es tan rápida como con el grupo threads. Las API relacionadas con el proceso, como process.chdir(), están disponibles en el grupo forks.

vmThreads*

Ejecuta las pruebas utilizando contexto VM (dentro de un entorno sandbox) en un grupo threads.

Esto acelera la ejecución de las pruebas, pero el módulo VM es inestable cuando se ejecuta código ESM. Tus pruebas pueden tener fugas de memoria; para evitarlo, considera editar manualmente el valor de poolOptions.vmThreads.memoryLimit.

WARNING

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

Los globales dentro de los módulos nativos, como (fs, path, etc.), difieren de los globales presentes en tu 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 que se usa en tu 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 tienes 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.

Ten en cuenta estos problemas al usar esta opción. El equipo de Vitest no puede solucionar ninguno de estos problemas.

vmForks*

Similar al grupo vmThreads, pero utiliza child_process en lugar de worker_threads a través de tinypool. La comunicación entre las pruebas y el proceso principal no es tan rápida como con el grupo vmThreads. Las API relacionadas con el proceso, como process.chdir(), están disponibles en el grupo vmForks. Ten en cuenta que este grupo tiene los mismos inconvenientes que se enumeran en vmThreads.

poolOptions* 1.0.0+

Tipo: Record<'threads' | 'forks' | 'vmThreads' | 'vmForks', {}>
Valor predeterminado: {}

poolOptions.threads

Opciones relacionadas con los hilos del grupo threads.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      threads: {
        // Opciones relacionadas con hilos aquí
      },
    },
  },
});

poolOptions.threads.maxThreads*

Tipo: number
Valor predeterminado: CPUs disponibles

Número máximo de hilos/procesos. También puedes usar la variable de entorno VITEST_MAX_THREADS.

poolOptions.threads.minThreads*

Tipo: number
Valor predeterminado: CPUs disponibles

Número mínimo de hilos/procesos. También puedes usar la variable de entorno VITEST_MIN_THREADS.

poolOptions.threads.singleThread

Tipo: boolean
Valor predeterminado: false

Ejecuta todas las pruebas con el mismo entorno en un único hilo de trabajo. Esto deshabilitará el aislamiento de módulos incorporado (tu código fuente o el código en línea se volverá a evaluar para cada prueba), pero puede mejorar el rendimiento de las pruebas.

WARNING

Aunque esta opción forzará la ejecución de las pruebas una tras otra, es diferente de --runInBand de Jest. Vitest utiliza procesos worker no solo para ejecutar pruebas en paralelo, sino también para proporcionar aislamiento. Al deshabilitar esta opción, las pruebas se ejecutarán secuencialmente, pero en el mismo contexto global, por lo que deberás proporcionar el aislamiento tú mismo.

Esto podría causar problemas si confías en el estado global (como suelen hacer los frameworks frontend) o si tu código depende de que el entorno se defina por separado para cada prueba. Pero puede acelerar tus pruebas (hasta 3 veces más rápido) si no dependen del estado global o pueden evitarlo fácilmente.

poolOptions.threads.useAtomics*

Tipo: boolean
Valor predeterminado: false

Usa Atomics para sincronizar hilos.

Esto puede mejorar el rendimiento en algunos casos, pero podría causar un fallo de segmentación en versiones anteriores de Node.js.

poolOptions.threads.isolate

Tipo: boolean
Valor predeterminado: true

Aísla el entorno de cada archivo de prueba.

poolOptions.threads.execArgv*

Tipo: string[]
Valor predeterminado: []

Pasa argumentos adicionales a node a los hilos. Consulta API de línea de comandos | Node.js para obtener más información.

WARNING

Ten cuidado al usarla, ya que algunas opciones pueden bloquear el worker, por ejemplo, --prof, --title. Consulta https://github.com/nodejs/node/issues/41103.

poolOptions.forks

Opciones relacionadas con los forks del grupo forks.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      forks: {
        // Opciones relacionadas con forks aquí
      },
    },
  },
});

poolOptions.forks.maxForks*

Tipo: number
Valor predeterminado: CPUs disponibles

Número máximo de procesos fork.

poolOptions.forks.minForks*

Tipo: number
Valor predeterminado: CPUs disponibles

Número mínimo de procesos fork.

poolOptions.forks.isolate

Tipo: boolean
Valor predeterminado: true

Aísla el entorno de cada archivo de prueba.

poolOptions.forks.singleFork

Tipo: boolean
Valor predeterminado: false

Ejecuta todas las pruebas con el mismo entorno en un único proceso hijo. Esto deshabilitará el aislamiento de módulos incorporado (tu código fuente o el código en línea se volverá a evaluar para cada prueba), pero puede mejorar el rendimiento de las pruebas.

WARNING

Aunque esta opción forzará la ejecución de las pruebas una tras otra, es diferente de --runInBand de Jest. Vitest utiliza procesos hijos no solo para ejecutar pruebas en paralelo, sino también para proporcionar aislamiento. Al deshabilitar esta opción, las pruebas se ejecutarán secuencialmente, pero en el mismo contexto global, por lo que deberás proporcionar el aislamiento tú mismo.

poolOptions.forks.execArgv*

Tipo: string[]
Valor predeterminado: []

Pasa argumentos adicionales al proceso node a los procesos hijos. Consulta API de línea de comandos | Node.js para obtener más información.

WARNING

Ten cuidado al usarla, ya que algunas opciones pueden bloquear el worker, por ejemplo, --prof, --title. Consulta https://github.com/nodejs/node/issues/41103.

poolOptions.vmThreads

Opciones relacionadas con los hilos VM del grupo vmThreads.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      vmThreads: {
        // Opciones relacionadas con hilos VM aquí
      },
    },
  },
});

poolOptions.vmThreads.maxThreads*

Tipo: number
Valor predeterminado: CPUs disponibles

Número máximo de hilos/procesos. También puedes usar la variable de entorno VITEST_MAX_THREADS.

poolOptions.vmThreads.minThreads*

Tipo: number
Valor predeterminado: CPUs disponibles

Número mínimo de hilos/procesos. También puedes usar la variable de entorno VITEST_MIN_THREADS.

poolOptions.vmThreads.memoryLimit*

Tipo: string | number
Valor predeterminado: 1 / CPU Cores

Especifica el límite de memoria para los procesos worker antes de que se reciclen. Este valor depende en gran medida de tu entorno, por lo que es mejor especificarlo manualmente en lugar de confiar en el valor predeterminado. La forma en que se calcula este valor se describe en poolOptions.vmThreads.memoryLimit

TIP

La implementación se basa en workerIdleMemoryLimit de Jest.

El límite se puede especificar de diferentes maneras y, en cualquier caso, se usa Math.floor para convertirlo en un valor entero:

<= 1: se supone que el valor es un porcentaje de la memoria del sistema. Entonces, 0.5 establece el límite de memoria del worker en la mitad de la memoria total del sistema.
\> 1: se supone que es un valor de byte fijo. Según la regla anterior, si quisieras un valor de 1 byte (no se recomienda), podrías 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 puede no funcionar en los procesos worker de Linux CircleCI debido a que se informa una memoria del sistema incorrecta.

poolOptions.vmThreads.useAtomics*

Tipo: boolean
Valor predeterminado: false

Usa Atomics para sincronizar hilos.

Esto puede mejorar el rendimiento en algunos casos, pero podría causar un fallo de segmentación en versiones anteriores de Node.js.

poolOptions.vmThreads.execArgv*

Tipo: string[]
Valor predeterminado: []

Pasa argumentos adicionales al proceso node al contexto de la VM. Consulta API de línea de comandos | Node.js para obtener más información.

WARNING

Ten cuidado al usarla, ya que algunas opciones pueden bloquear el worker, por ejemplo, --prof, --title. Consulta https://github.com/nodejs/node/issues/41103.

poolOptions.vmForks

Opciones relacionadas con los forks VM del grupo vmForks.

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      vmForks: {
        // Opciones relacionadas con forks VM aquí
      },
    },
  },
});

poolOptions.vmForks.maxForks*

Tipo: number
Valor predeterminado: CPUs disponibles

Número máximo de hilos/procesos. También puedes usar la variable de entorno VITEST_MAX_FORKS.

poolOptions.vmForks.minForks*

Tipo: number
Valor predeterminado: CPUs disponibles

Número mínimo de hilos/procesos. También puedes usar la variable de entorno VITEST_MIN_FORKS.

poolOptions.vmForks.memoryLimit*

Tipo: string | number
Valor predeterminado: 1 / CPU Cores

poolOptions.vmForks.execArgv*

Tipo: string[]
Valor predeterminado: []

Pasa argumentos adicionales al proceso node al contexto de la VM. Consulta API de línea de comandos | Node.js para obtener más información.

WARNING

Ten cuidado al usarla, ya que algunas opciones pueden bloquear el worker, por ejemplo, --prof, --title. Consulta https://github.com/nodejs/node/issues/41103.

fileParallelism 1.1.0+

Tipo: boolean
Valor por defecto: true
CLI: --no-file-parallelism, --fileParallelism=false

Indica si todos los archivos de prueba deben ejecutarse en paralelo. Si se establece en false, las opciones maxWorkers y minWorkers se forzarán a 1.

TIP

Esta opción no afecta a las pruebas que se ejecutan dentro del mismo archivo. Para ejecutarlas en paralelo, utiliza la opción concurrent en describe o mediante una configuración.

maxWorkers 1.1.0+

Tipo: number

Número máximo de workers que se utilizarán para ejecutar las pruebas. poolOptions.{threads,vmThreads}.maxThreads/poolOptions.forks.maxForks tienen prioridad sobre esta opción.

minWorkers 1.1.0+

Tipo: number

Número mínimo de workers que se utilizarán para ejecutar las pruebas. poolOptions.{threads,vmThreads}.minThreads/poolOptions.forks.maxForks tienen prioridad sobre esta opción.

testTimeout

Tipo: number
Valor por defecto: 5000
CLI: --test-timeout=5000, --testTimeout=5000

Tiempo máximo de espera para una prueba, en milisegundos.

hookTimeout

Tipo: number
Valor por defecto: 10000
CLI: --hook-timeout=10000, --hookTimeout=10000

Tiempo máximo de espera para un hook, en milisegundos.

teardownTimeout*

Tipo: number
Valor por defecto: 10000
CLI: --teardown-timeout=5000, --teardownTimeout=5000

Tiempo máximo de espera para el proceso de finalización cuando Vitest se cierra, en milisegundos.

silent*

Tipo: boolean
Valor por defecto: false
CLI: --silent, --silent=false

Suprime la salida de la consola durante la ejecución de las pruebas.

setupFiles

Tipo: string | string[]

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

INFO

Modificar los archivos de configuración provocará la repetición de todas las pruebas.

Puedes usar process.env.VITEST_POOL_ID (string similar a un entero) dentro de estos archivos para distinguir entre los diferentes workers.

TIP

Ten en cuenta que si estás ejecutando Vitest con la opción --isolate=false, este archivo de configuración se ejecutará varias veces en el mismo ámbito global. Esto significa que estarás accediendo al mismo objeto global antes de cada prueba, así que asegúrate de no repetir acciones innecesarias.

Por ejemplo, puedes depender de 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 finalización (ejemplo).

INFO

Es posible tener múltiples archivos globalSetup. Las funciones setup y teardown se ejecutan secuencialmente, con las funciones teardown ejecutándose en orden inverso.

WARNING

Desde Vitest 1.0.0-beta, la configuración global solo se ejecuta si hay al menos una prueba en ejecución. Esto significa que la configuración global podría comenzar a ejecutarse durante el modo de vigilancia después de que se modifique un archivo de prueba (el archivo de prueba esperará a que finalice la configuración global antes de ejecutarse).

Ten en cuenta que la configuración global se ejecuta en un ámbito global diferente, por lo que tus pruebas no tendrán acceso a las variables definidas aquí. Sin embargo, a partir de la versión 1.0.0, puedes pasar datos serializables a las pruebas a través del método provide:

globalSetup.jsglobalSetup.tsexample.test.js

export default function setup({ provide }) {
  provide('wsPort', 3000);
}

import type { GlobalSetupContext } from 'vitest/node';

export default function setup({ provide }: GlobalSetupContext) {
  provide('wsPort', 3000);
}

// You can also extend `ProvidedContext` type
// to have type safe access to `provide/inject` methods:
declare module 'vitest' {
  export interface ProvidedContext {
    wsPort: number;
  }
}

import { inject } from 'vitest';

inject('wsPort') === 3000;

watchExclude*

Tipo: string[]
Valor por defecto: ['**/node_modules/**', '**/dist/**']
Obsoleto: utiliza server.watch.ignored

Patrón glob de rutas de archivo que se ignorarán para evitar activar la repetición de la vigilancia.

forceRerunTriggers*

Tipo: string[]
Valor por defecto: ['**/package.json/**', '**/vitest.config.*/**', '**/vite.config.*/**']

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

Útil si estás 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úrate de que tus archivos no estén excluidos por watchExclude.

coverage*

Puedes utilizar v8, istanbul o una solución de cobertura personalizada para la recolección de 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 estás utilizando opciones de cobertura con la notación de puntos, no olvides especificar --coverage.enabled. No proporciones una única opción --coverage en ese caso.

coverage.provider

Tipo: 'v8' | 'istanbul' | 'custom'
Valor por defecto: 'v8'
CLI: --coverage.provider=<provider>

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

coverage.enabled

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

Habilita la recolección de cobertura. Se puede sobrescribir utilizando la opción CLI --coverage.

coverage.include

Tipo: string[]
Valor por defecto: ['**']
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.include=<path>, --coverage.include=<path1> --coverage.include=<path2>

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

coverage.extension

Tipo: string | string[]
Valor por defecto: ['.js', '.cjs', '.mjs', '.ts', '.mts', '.cts', '.tsx', '.jsx', '.vue', '.svelte', '.marko']
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.extension=<extension>, --coverage.extension=<extension1> --coverage.extension=<extension2>

coverage.exclude

Tipo: string[]
Valor por defecto:

[
  'coverage/**',
  'dist/**',
  '**/[.]**',
  'packages/*/test?(s)/**',
  '**/*.d.ts',
  '**/virtual:*',
  '**/__x00__*',
  '**/\x00*',
  'cypress/**',
  'test?(s)/**',
  'test?(-*).?(c|m)[jt]s?(x)',
  '**/*{.,-}{test,spec}?(-d).?(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=<path>, --coverage.exclude=<path1> --coverage.exclude=<path2>

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

Esta opción anula todos los valores por defecto. Para extender los valores por defecto agregando nuevos patrones a ignorar, haz lo siguiente:

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

export default defineConfig({
  test: {
    coverage: {
      exclude: ['**/custom-pattern/**', ...coverageConfigDefaults.exclude],
    },
  },
});

coverage.all

Tipo: boolean
Valor por defecto: true (desde Vitest 1.0.0)
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.all, --coverage.all=false

Indica si se deben incluir todos los archivos, incluso los no probados, en el informe de cobertura.

coverage.clean

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

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

coverage.cleanOnRerun

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

Elimina el informe de cobertura al volver a ejecutar la vigilancia.

coverage.reportsDirectory

Tipo: string
Valor por defecto: './coverage'
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.reportsDirectory=<path>

WARNING

Vitest eliminará este directorio antes de ejecutar las pruebas si coverage.clean está habilitado (valor por defecto).

Directorio donde se guardará el informe de cobertura.

Para previsualizar el informe de cobertura en la salida del reporter HTML, esta opción debe establecerse como un subdirectorio del directorio del informe HTML (por ejemplo, ./html/coverage).

coverage.reporter

Tipo: string | string[] | [string, {}][]
Valor por defecto: ['text', 'html', 'clover', 'json']
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.reporter=<reporter>, --coverage.reporter=<reporter1> --coverage.reporter=<reporter2>

Reporters de cobertura que se utilizarán. Consulta la documentación de istanbul para obtener una lista detallada de todos los reporters. Consulta @types/istanbul-reporter para obtener detalles sobre las opciones específicas del reporter.

El reporter puede definirse de tres maneras diferentes:

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

Uno o varios reporters con opciones:

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

Desde Vitest 1.2.0, también puedes pasar reporters de cobertura personalizados. Consulta Guía - Reporter de Cobertura Personalizado para obtener más información.

{
  reporter: [
    // Specify reporter using name of the NPM package
    '@vitest/custom-coverage-reporter',
    ['@vitest/custom-coverage-reporter', { someOption: true }],

    // Specify reporter using local path
    '/absolute/path/to/custom-reporter.cjs',
    ['/absolute/path/to/custom-reporter.cjs', { someOption: true }],
  ];
}

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

coverage.reportOnFailure 0.31.2+

Tipo: boolean
Valor por defecto: false (desde Vitest 0.34.0)
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.reportOnFailure, --coverage.reportOnFailure=false

Genera un informe de cobertura incluso cuando las pruebas fallan.

coverage.allowExternal

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

Recopila la cobertura de archivos fuera del directorio raíz del proyecto.

coverage.skipFull

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

No muestra los archivos con una cobertura del 100% de declaraciones, ramas y funciones.

coverage.thresholds

Opciones para los umbrales de cobertura.

coverage.thresholds.lines

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

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

coverage.thresholds.functions

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

Umbral global para funciones. Consulta la documentación de istanbul para obtener más información.

coverage.thresholds.branches

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

Umbral global para ramas. Consulta la documentación de istanbul para obtener más información.

coverage.thresholds.statements

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

Umbral global para declaraciones. Consulta la documentación de istanbul para obtener más información.

coverage.thresholds.perFile

Tipo: boolean
Valor por defecto: false
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.thresholds.perFile, --coverage.thresholds.perFile=false

Verifica los umbrales por archivo.

coverage.thresholds.autoUpdate

Tipo: boolean
Valor por defecto: false
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.thresholds.autoUpdate=<boolean>

Actualiza todos los valores de umbral lines, functions, branches y statements 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 se mejora la cobertura.

coverage.thresholds.100

Tipo: boolean
Valor por defecto: false
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.thresholds.100, --coverage.thresholds.100=false

Establece los umbrales globales en 100. Atajo para --coverage.thresholds.lines 100 --coverage.thresholds.functions 100 --coverage.thresholds.branches 100 --coverage.thresholds.statements 100.

coverage.thresholds[glob-pattern]

Tipo: { statements?: number functions?: number branches?: number lines?: number }
Valor por defecto: undefined
Disponible para proveedores: 'v8' | 'istanbul'

Establece los umbrales para los archivos que coinciden con el patrón glob.

{
  coverage: {
    thresholds: {
      // Thresholds for all files
      functions: 95,
      branches: 70,

      // Thresholds for matching glob pattern
      'src/utils/**.ts': {
        statements: 95,
        functions: 90,
        branches: 85,
        lines: 80,
      },

      // Files matching this pattern will only have lines thresholds set.
      // Global thresholds are not inherited.
      '**/math.ts': {
        lines: 100,
      }
    }
  }
}

coverage.ignoreEmptyLines

Tipo: boolean
Valor por defecto: false
Disponible para proveedores: 'v8'
CLI: --coverage.ignoreEmptyLines=<boolean>

Ignora las líneas vacías, los comentarios y otro código que no es de tiempo de ejecución, como los tipos de TypeScript.

Esta opción solo funciona si el compilador utilizado elimina los comentarios y otro código que no es de tiempo de ejecución del código transpilado. De forma predeterminada, Vite utiliza ESBuild, que elimina los comentarios y los tipos de Typescript de los archivos .ts, .tsx y .jsx.

Si también deseas aplicar ESBuild a otros archivos, defínelos en las opciones esbuild:

import { defineConfig } from 'vitest/config';

export default defineConfig({
  esbuild: {
    // Transpile all files with ESBuild to remove comments from code coverage.
    // Required for `test.coverage.ignoreEmptyLines` to work:
    include: ['**/*.js', '**/*.jsx', '**/*.mjs', '**/*.ts', '**/*.tsx'],
  },
  test: {
    coverage: {
      provider: 'v8',
      ignoreEmptyLines: true,
    },
  },
});

coverage.ignoreClassMethods

Tipo: string[]
Valor por defecto: []
Disponible para proveedores: 'istanbul'
CLI: --coverage.ignoreClassMethods=<method>

Establece la matriz de nombres de métodos de clase que se ignorarán para 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]
}

Valor por defecto:

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

Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.watermarks.statements=50,80, --coverage.watermarks.branches=50,80

Niveles de referencia para declaraciones, líneas, ramas y funciones. Consulta la documentación de istanbul para obtener más información.

coverage.processingConcurrency

Tipo: number
Valor por defecto: Math.min(20, os.availableParallelism?.() ?? os.cpus().length)
Disponible para proveedores: 'v8' | 'istanbul'
CLI: --coverage.processingConcurrency=<number>

Límite de concurrencia utilizado al procesar los resultados de la cobertura.

coverage.customProviderModule

Tipo: string
Disponible para proveedores: 'custom'
CLI: --coverage.customProviderModule=<path or module name>

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

testNamePattern*

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

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

import { expect, test } from 'vitest';

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

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

open*

Tipo: boolean
Predeterminado: !process.env.CI
CLI: --open, --open=false

Abre la interfaz de usuario de Vitest (en desarrollo).

api

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

Activa un servidor que escucha en un puerto y sirve la API de Vitest. Cuando se establece en true, el puerto predeterminado es 51204.

browser 0.29.4+

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

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

NOTA

Para más información sobre las pruebas en un navegador real, consulte la página de la guía.

WARNING

Esta es una característica experimental. Los cambios importantes podrían no seguir SemVer, por lo que se recomienda fijar la versión de Vitest al usarla.

browser.enabled

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

Habilita la ejecución de todas las pruebas dentro de un navegador. 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
custom: cualquier cadena que se pasará al proveedor

browser.headless

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

Ejecuta el navegador en modo headless (sin interfaz gráfica). Si Vitest se ejecuta en un entorno de CI (Integración Continua), esta opción se habilita por defecto.

browser.isolate

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

Ejecuta cada prueba en un iframe separado.

browser.fileParallelism 1.3.0+

Tipo: boolean
Predeterminado: el mismo que fileParallelism
CLI: --browser.fileParallelism=false

Deshabilita el uso de APIs interactivas (como hacer clic o pasar el ratón) porque hay varios iframes en la pantalla simultáneamente. Sin embargo, si las pruebas no dependen de estas APIs, podría ser más rápido ejecutarlas todas al mismo tiempo.

TIP

Si ha deshabilitado el aislamiento a través de browser.isolate=false, sus archivos de prueba seguirán ejecutándose uno tras otro debido a la naturaleza del ejecutor de pruebas.

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 la opción test.api.

browser.provider

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

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

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

WARNING

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

browser.providerOptions 1.0.0+

Tipo: BrowserProviderOptions

Opciones que se pasarán al proveedor al llamar a provider.initialize.

export default defineConfig({
  test: {
    browser: {
      providerOptions: {
        launch: {
          devtools: true,
        },
      },
    },
  },
});

TIP

Para mejorar la seguridad de tipos al usar proveedores integrados, puede añadir uno de estos tipos (correspondiente al proveedor que esté utilizando) al campo compilerOptions.types en su archivo tsconfig.json.

json

{
  "compilerOptions": {
    "types": [
      "@vitest/browser/providers/webdriverio",
      "@vitest/browser/providers/playwright"
    ]
  }
}

browser.slowHijackESM 0.31.0+

Tipo: boolean
Predeterminado: false

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

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

Si necesita espiar los módulos ES con vi.spyOn, puede habilitar esta característica experimental para permitir espiar las exportaciones de módulos.

browser.indexScripts 1.6.0+

Tipo: BrowserScript[]
Predeterminado: []

Scripts personalizados que se inyectarán en el HTML del índice antes de que se inicien los iframes de prueba. Este documento HTML solo configura iframes y no importa su código.

El src y el content del script serán procesados por los plugins de Vite. El script debe proporcionarse en la siguiente estructura:

export interface BrowserScript {
  /**
   * Si se proporciona "content" y el tipo es "module", este será su identificador.
   *
   * Si está utilizando TypeScript, puede agregar la extensión `.ts` aquí, por ejemplo.
   * @default `injected-${index}.js`
   */
  id?: string;
  /**
   * Contenido de JavaScript que se inyectará. Esta cadena es procesada por los plugins de Vite si el tipo es "module".
   *
   * Puede usar `id` para darle a Vite una pista sobre la extensión del archivo.
   */
  content?: string;
  /**
   * Ruta al script. Este valor es resuelto por Vite, por lo que puede ser un módulo de nodo o una ruta de archivo.
   */
  src?: string;
  /**
   * Si el script debe cargarse de manera asíncrona.
   */
  async?: boolean;
  /**
   * Tipo de script.
   * @default 'module'
   */
  type?: string;
}

browser.testerScripts 1.6.0+

Tipo: BrowserScript[]
Predeterminado: []

Scripts personalizados que se inyectarán en el HTML del probador antes de que se inicie el entorno de pruebas. Esto es útil para inyectar polyfills requeridos para la implementación del navegador Vitest. Se recomienda usar setupFiles en la mayoría de los casos en lugar de esta opción.

El src y el content del script serán procesados por los plugins de Vite.

clearMocks

Tipo: boolean
Predeterminado: false

Llama a .mockClear() en todos los espías antes de cada prueba. Esto borra el historial de simulacros, pero no restablece su implementación a la predeterminada.

mockReset

Tipo: boolean
Predeterminado: false

Llama a .mockReset() en todos los espías antes de cada prueba. Esto borra el historial de simulacros y restablece su implementación a una función vacía (que devuelve undefined).

restoreMocks

Tipo: boolean
Predeterminado: false

Llama a .mockRestore() en todos los espías antes de cada prueba. Esto borra el historial de simulacros y restablece su implementación a la original.

unstubEnvs 0.26.0+

Tipo: boolean
Predeterminado: false

Llama a vi.unstubAllEnvs antes de cada prueba.

unstubGlobals 0.26.0+

Tipo: boolean
Predeterminado: false

Llama a vi.unstubAllGlobals antes de cada prueba.

testTransformMode 0.34.0+

Tipo: { web?, ssr? }

Determina el método de transformación para todos los módulos importados dentro de 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 dentro de las pruebas especificadas. Los plugins de Vite recibirán el indicador ssr: true al procesar esos archivos.

testTransformMode.web

Tipo: string[]
Predeterminado: []

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

snapshotFormat*

Tipo: PrettyFormatOptions

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

TIP

Tenga en cuenta que se ignorará el campo plugins en este objeto.

Si necesita extender el serializador de instantáneas a través de plugins de pretty-format, utilice la API expect.addSnapshotSerializer o la opción snapshotSerializers.

snapshotSerializers* 1.3.0+

Tipo: string[]
Predeterminado: []

Una lista de rutas a módulos serializadores de instantáneas para pruebas de instantáneas. Es útil si desea agregar serializadores de instantáneas personalizados. Consulte Serializador personalizado para obtener más información.

resolveSnapshotPath*

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

Anula la ruta de instantánea predeterminada. 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: !process.env.CI
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 la memoria 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 excluye, los archivos CSS se sustituirán por cadenas vacías para evitar su procesamiento posterior. Los módulos CSS devolverán un proxy para no afectar al tiempo de ejecución.

css.include

Tipo: RegExp | RegExp[]
Predeterminado: []

Patrón RegExp para 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 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 (scope) limitado. Puede elegir una de las siguientes opciones:

stable: los nombres de clase se generarán como _${name}_${hashedFilename}, lo que implica que la clase generada permanecerá invariable si el contenido CSS se modifica, pero cambiará si se modifica el nombre del archivo o si el archivo se traslada a otra carpeta. Esta configuración resulta útil al utilizar la función de instantáneas.
scoped: los nombres de clase se generarán de la forma habitual, respetando el método css.modules.generateScopeName, si está definido y el procesamiento de CSS está habilitado. De forma predeterminada, el nombre de archivo se generará como _${name}_${hash}, donde el hash incluye tanto el nombre como el contenido del archivo.
non-scoped: los nombres de clase no tendrán un ámbito (scope) limitado.

WARNING

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

maxConcurrency

Tipo: number
Predeterminado: 5
CLI: --max-concurrency=10, --maxConcurrency=10

Cantidad de pruebas marcadas con test.concurrent que pueden ejecutarse simultáneamente.

Las pruebas que excedan este límite se pondrán en cola y se ejecutarán cuando haya disponibilidad.

cache*

Tipo: false
CLI: --no-cache, --cache=false

Desactiva la caché con esta opción. Actualmente, Vitest guarda en caché los resultados para priorizar la ejecución de pruebas largas o las que han fallado.

sequence

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

Opciones para definir el orden de ejecución de las pruebas.

Puede pasar opciones de secuencia a la CLI usando la 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 la división en fragmentos y el ordenamiento de las pruebas. Puede extender BaseSequencer desde vitest/node si solo necesita redefinir uno de los métodos sort o shard, pero ambos deben existir.

La división en fragmentos ocurre antes del ordenamiento, y solo si se proporciona la opción --shard.

sequence.shuffle

Tipo: boolean | { files?, tests? }
Predeterminado: false
CLI: --sequence.shuffle, --sequence.shuffle=false

Habilite esta opción, o use el argumento de la CLI --sequence.shuffle, si desea que los archivos y las pruebas se ejecuten de forma aleatoria.

Vitest normalmente usa la caché para ordenar las pruebas, de modo que las pruebas de larga duración comiencen antes; esto acelera la ejecución de las pruebas. Al ejecutar archivos y pruebas en orden aleatorio, se pierde esta optimización de rendimiento, aunque puede ser útil para detectar pruebas que dependen accidentalmente de una ejecución anterior.

sequence.shuffle.files 1.4.0+

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

Indica si se deben aleatorizar los archivos. Tenga en cuenta que las pruebas de larga duración no comenzarán antes si habilita esta opción.

sequence.shuffle.tests 1.4.0+

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

Indica si se deben aleatorizar las pruebas.

sequence.concurrent 0.32.2+

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

Habilite esta opción, o use el argumento de la CLI --sequence.concurrent, si desea que las pruebas se ejecuten en paralelo.

sequence.seed*

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

Define la semilla para el orden aleatorio, si las pruebas se ejecutan en orden aleatorio.

sequence.hooks

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

Define el orden de ejecución de los hooks.

stack ordenará los hooks "after" en orden inverso, y 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á todos los hooks en paralelo como un único grupo (los hooks en las suites principales seguirán ejecutándose antes que los hooks de la suite actual).

TIP

Esta opción no afecta a onTestFinished. Siempre se llama en orden inverso.

sequence.setupFiles 0.29.3+

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

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.enabled 1.0.0+

Tipo: boolean
Predeterminado: false
CLI: --typecheck, --typecheck.enabled

Activa la verificación de tipos además de las pruebas normales.

typecheck.only 1.0.0+

Tipo: boolean
Predeterminado: false
CLI: --typecheck.only

Ejecuta solo las pruebas de verificación de tipos, siempre y cuando la verificación de tipos esté habilitada. Cuando se usa la CLI, esta opción habilitará automáticamente la verificación de tipos.

typecheck.checker

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

Especifica qué herramienta usar para la verificación de tipos. Vitest generará un proceso con ciertos parámetros para facilitar el análisis, dependiendo del tipo. El verificador debe generar resultados con el mismo formato que tsc.

Necesita 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 identificar archivos de prueba.

typecheck.exclude

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

Patrón glob para los 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

Evita que la ejecución falle si Vitest encuentra errores fuera de los archivos de prueba. Esto no mostrará ningún error que no sea de prueba.

De forma predeterminada, si Vitest encuentra un error de origen, fallará el conjunto de pruebas.

typecheck.tsconfig

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

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

slowTestThreshold*

Tipo: number
Predeterminado: 300
CLI: --slow-test-threshold=<number>, --slowTestThreshold=<number>

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

chaiConfig 0.30.0+

Tipo: { includeStack?, showDiff?, truncateThreshold? }
Predeterminado: { includeStack: false, showDiff: true, truncateThreshold: 40 }

Equivalente a la configuración de Chai.

chaiConfig.includeStack

Tipo: boolean
Predeterminado: false

Determina si el stack trace se incluye en los mensajes de error de Assertion. El valor predeterminado de false suprime el seguimiento de la pila en el mensaje de error.

chaiConfig.showDiff

Tipo: boolean
Predeterminado: true

Influye en si la bandera showDiff debe incluirse o no 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 para 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 0.31.0+

Tipo: number
Predeterminado: 0
CLI: --bail=<value>

Interrumpe la ejecución después de que falle una cierta cantidad de pruebas.

De forma predeterminada, Vitest ejecutará todos sus casos de prueba, incluso si algunos de ellos fallan. Esto puede no ser deseado en las compilaciones de CI, donde solo se busca que sean 100% exitosas, y se prefiere 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 se ejecuten más pruebas cuando se han producido fallas.

retry 0.32.3+

Tipo: number
Predeterminado: 0
CLI: --retry=<value>

Reintenta la prueba una cierta cantidad de veces al fallar.

onConsoleLog*

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

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

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

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    onConsoleLog(log: string, type: 'stdout' | 'stderr'): boolean | void {
      return !(log === 'message from third party library' && type === 'stdout');
    },
  },
});

onStackTrace* 1.0.0+

Tipo: (error: Error, frame: ParsedStack) => boolean | void

Filtra cada frame de los stack traces al manejar errores. El primer argumento, error, es un objeto con las mismas propiedades que un Error estándar, pero no es una instancia real.

Puede ser útil para filtrar los frames del stack trace de bibliotecas de terceros.

import type { ParsedStack } from 'vitest';
import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    onStackTrace(error: Error, { file }: ParsedStack): boolean | void {
      // Si encontramos un ReferenceError, muestra todo el stack.
      if (error.name === 'ReferenceError') return;

      // Rechaza todos los frames de bibliotecas de terceros.
      if (file.includes('node_modules')) return false;
    },
  },
});

diff 0.34.5+

Tipo: string
CLI: --diff=<value>

Ruta al archivo de configuración para generar diferencias visuales. Ú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',
  },
});

diff.truncateThreshold

Tipo: number
Predeterminado: 0

Longitud máxima para mostrar diferencias. Las diferencias por encima de este umbral se truncarán. El truncamiento no tendrá efecto con el valor predeterminado 0.

diff.truncateAnnotation

Tipo: string
Predeterminado: '... Diff result is truncated'

Mensaje que aparece al truncar diferencias.

diff.truncateAnnotationColor

Tipo: DiffOptionsColor = (arg: string) => string
Predeterminado: noColor = (string: string): string => string

Color de la anotación de truncamiento, el valor predeterminado es la salida sin color.

fakeTimers

Tipo: FakeTimerInstallOpts

Opciones que Vitest pasará a @sinon/fake-timers cuando se use vi.useFakeTimers().

fakeTimers.now

Tipo: number | Date
Predeterminado: Date.now()

Configura temporizadores simulados usando el timestamp Unix indicado.

fakeTimers.toFake

Tipo: ('setTimeout' | 'clearTimeout' | 'setImmediate' | 'clearImmediate' | 'setInterval' | 'clearInterval' | 'Date' | 'nextTick' | 'hrtime' | 'requestAnimationFrame' | 'cancelAnimationFrame' | 'requestIdleCallback' | 'cancelIdleCallback' | 'performance' | 'queueMicrotask')[]
Predeterminado: ['setTimeout', 'clearTimeout', 'setImmediate', 'clearImmediate', 'setInterval', 'clearInterval', 'Date']

Lista de APIs y métodos globales a simular.

Para simular solo setTimeout() y nextTick(), especifique esta propiedad como ['setTimeout', 'nextTick'].

La simulación de nextTick no es compatible al ejecutar Vitest dentro de node:child_process usando --pool=forks. NodeJS usa process.nextTick internamente en node:child_process y se bloquea cuando se simula. La simulación de nextTick es compatible cuando se ejecuta Vitest con --pool=threads.

fakeTimers.loopLimit

Tipo: number
Predeterminado: 10_000

El número máximo de temporizadores que se ejecutarán al llamar a vi.runAllTimers().

fakeTimers.shouldAdvanceTime

Tipo: boolean
Predeterminado: false

Indica a @sinonjs/fake-timers que avance el tiempo simulado automáticamente basándose en los cambios del tiempo real del sistema (por ejemplo, el tiempo simulado se incrementará en 20 ms por cada cambio de 20 ms en el tiempo real).

fakeTimers.advanceTimeDelta

Tipo: number
Predeterminado: 20

Relevante solo cuando se usa con shouldAdvanceTime: true. Incrementa el tiempo simulado en advanceTimeDelta ms por cada cambio de advanceTimeDelta ms en el tiempo real del sistema.

fakeTimers.shouldClearNativeTimers

Tipo: boolean
Predeterminado: false

Indica a los temporizadores falsos que eliminen los temporizadores "nativos" (es decir, los reales) delegando en sus respectivos controladores. Estos no se borran de forma predeterminada, lo que lleva a un comportamiento potencialmente inesperado si los temporizadores existían antes de iniciar la sesión de temporizadores falsos.

workspace* 1.1.0+

Tipo: string
CLI: --workspace=./file.js
Predeterminado: vitest.{workspace,projects}.{js,ts,json} cerca del archivo de configuración o la raíz

Ruta a un archivo de configuración de espacio de trabajo relativo a root.

isolate 1.1.0+

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

Ejecuta las pruebas en aislamiento. Esta opción no tiene ningún efecto en los pools vmThreads y vmForks.

Desactivar esto puede mejorar el rendimiento si su código no depende de efectos secundarios (algo común en proyectos con entorno node).

TIP

Puede deshabilitar el aislamiento para pools específicos mediante la propiedad poolOptions.

includeTaskLocation 1.4.0+

Tipo: boolean
Predeterminado: false

Indica si la propiedad location debe incluirse cuando la API de Vitest recibe tareas en reporters. Si tiene muchas pruebas, esto podría causar una pequeña regresión en el rendimiento.

La propiedad location tiene valores column y line que corresponden a la posición de test o describe en el archivo original.

TIP

Esta opción no tiene ningún efecto si no usa código personalizado que dependa de esto.

snapshotEnvironment 1.6.0+

Tipo: string

Ruta a una implementación personalizada del entorno de instantáneas. Esto es útil si ejecuta sus pruebas en un entorno que no es compatible con las API de Node.js. Esta opción no tiene ningún efecto en un ejecutor de navegador.

Este objeto debe implementar la interfaz SnapshotEnvironment y se utiliza para resolver y leer/escribir archivos de instantáneas:

export interface SnapshotEnvironment {
  getVersion: () => string;
  getHeader: () => string;
  resolvePath: (filepath: string) => Promise<string>;
  resolveRawPath: (testPath: string, rawPath: string) => Promise<string>;
  saveSnapshotFile: (filepath: string, snapshot: string) => Promise<void>;
  readSnapshotFile: (filepath: string) => Promise<string | null>;
  removeSnapshotFile: (filepath: string) => Promise<void>;
}

Puede extender el VitestSnapshotEnvironment predeterminado desde el punto de entrada vitest/snapshot si necesita sobrescribir solo una parte de la API.

WARNING

Esta es una opción de bajo nivel y debe usarse solo para casos avanzados en los que no tiene acceso a las API predeterminadas de Node.js.

Si solo necesita configurar la función de instantáneas, use las opciones snapshotFormat o resolveSnapshotPath.

Configuración de Vitest ​

include ​

exclude ​

includeSource ​

server 0.34.0+ ​

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 0.34.0+ ​

deps.optimizer.{mode}.enabled ​

deps.web 0.34.2+ ​

deps.web.transformAssets ​

deps.web.transformCss ​

deps.web.transformGlobPattern ​

deps.interopDefault ​

deps.moduleDirectories ​

runner ​

benchmark ​

benchmark.include ​

benchmark.exclude ​

benchmark.includeSource ​

benchmark.reporters ​

benchmark.outputFile ​

benchmark.outputJson 1.6.0+ ​

benchmark.compare 1.6.0+ ​

alias ​

globals ​

environment ​

environmentOptions ​

environmentMatchGlobs ​

poolMatchGlobs 0.29.4+ ​

update* ​

watch* ​

root ​

reporters* ​

outputFile* ​

pool* 1.0.0+ ​

threads* ​

forks* ​

vmThreads* ​

vmForks* ​

poolOptions* 1.0.0+ ​

poolOptions.threads ​

poolOptions.threads.maxThreads* ​

poolOptions.threads.minThreads* ​

poolOptions.threads.singleThread ​

poolOptions.threads.useAtomics* ​

poolOptions.threads.isolate ​

poolOptions.threads.execArgv* ​

poolOptions.forks ​

poolOptions.forks.maxForks* ​

poolOptions.forks.minForks* ​

poolOptions.forks.isolate ​

poolOptions.forks.singleFork ​

poolOptions.forks.execArgv* ​

poolOptions.vmThreads ​

poolOptions.vmThreads.maxThreads* ​

poolOptions.vmThreads.minThreads* ​

poolOptions.vmThreads.memoryLimit* ​

poolOptions.vmThreads.useAtomics* ​

poolOptions.vmThreads.execArgv* ​

poolOptions.vmForks ​

poolOptions.vmForks.maxForks* ​

poolOptions.vmForks.minForks* ​

poolOptions.vmForks.memoryLimit* ​

poolOptions.vmForks.execArgv* ​

fileParallelism 1.1.0+ ​

maxWorkers 1.1.0+ ​

minWorkers 1.1.0+ ​

testTimeout ​

hookTimeout ​

teardownTimeout* ​

silent* ​

Configuración de Vitest

include

exclude

includeSource

server 0.34.0+

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 0.34.0+

deps.optimizer.{mode}.enabled

deps.web 0.34.2+

deps.web.transformAssets

deps.web.transformCss

deps.web.transformGlobPattern

deps.interopDefault

deps.moduleDirectories

runner

benchmark

benchmark.include

benchmark.exclude

benchmark.includeSource

benchmark.reporters

benchmark.outputFile

benchmark.outputJson 1.6.0+

benchmark.compare 1.6.0+

alias

globals

environment

environmentOptions

environmentMatchGlobs

poolMatchGlobs 0.29.4+

update*

watch*

root

reporters*

outputFile*

pool* 1.0.0+

threads*

forks*

vmThreads*

vmForks*

poolOptions* 1.0.0+

poolOptions.threads

poolOptions.threads.maxThreads*

poolOptions.threads.minThreads*

poolOptions.threads.singleThread

poolOptions.threads.useAtomics*

poolOptions.threads.isolate

poolOptions.threads.execArgv*

poolOptions.forks

poolOptions.forks.maxForks*

poolOptions.forks.minForks*

poolOptions.forks.isolate

poolOptions.forks.singleFork

poolOptions.forks.execArgv*

poolOptions.vmThreads

poolOptions.vmThreads.maxThreads*

poolOptions.vmThreads.minThreads*

poolOptions.vmThreads.memoryLimit*

poolOptions.vmThreads.useAtomics*

poolOptions.vmThreads.execArgv*

poolOptions.vmForks

poolOptions.vmForks.maxForks*

poolOptions.vmForks.minForks*

poolOptions.vmForks.memoryLimit*

poolOptions.vmForks.execArgv*

fileParallelism 1.1.0+

maxWorkers 1.1.0+

minWorkers 1.1.0+

testTimeout

hookTimeout

teardownTimeout*

silent*