Saltar al contenido

¿Vitest lento en CI? Arranque, imports y pools

Última actualización

Cuando Vitest va lento, la causa casi siempre es una de cuatro: la creación del entorno, las importaciones lentas, la sobrecarga aislamiento de las pruebas o muy pocos workers en CI. Esta guía explica por qué Vitest es lento al iniciar y en CI, cómo corregir las importaciones lentas, cómo encontrar las pruebas lentas y cómo repartirlas en shards. Es una hermana de Jest lento y forma parte del grupo de pruebas e2e lentas.

Vitest cambia los nombres de algunas opciones entre versiones principales, sobre todo en lo relativo a los pools. Cuando un nombre sea relevante, consulte la referencia de configuración de su versión.

Analice primero: la línea Duration

La línea de resumen de Vitest desglosa en qué se fue el tiempo:

Duration 3.76s (environment 79%, import 13%, transform 6%, tests 1%, setup 1%)

Los porcentajes son proporciones del tiempo registrado en todos los workers, no del tiempo de reloj. Léalos como un diagnóstico:

  • environment alto: creación de jsdom o happy-dom para cada archivo. Solución: use node siempre que sea posible.
  • import / transform alto: importaciones o transformaciones lentas. Solución: vea abajo.
  • tests alto: las propias pruebas son lentas. Corrija las pruebas.
  • setup / worker alto: setupFiles o la sobrecarga de aislamiento por archivo.

Inicio lento de Vitest

El coste de arranque se paga en cada ejecución y, con aislamiento, en cada archivo de prueba. Para reducirlo:

  • Use el entorno node por defecto y active jsdom por archivo con // @vitest-environment jsdom.
  • Mantenga setupFiles ligero. La configuración pesada (iniciar servidores, cargar fixtures) debe ir en globalSetup, que se ejecuta una sola vez.
  • Ejecute vitest run en CI en lugar del modo watch, y guarde en caché node_modules con la caché de setup-node. Consulte caché en GitHub Actions.

Importaciones lentas de Vitest

Vitest evalúa cada módulo importado en cada archivo de prueba aislado. Si muchos archivos importan el mismo grafo grande, cada uno paga el coste de nuevo. La causa más habitual son los archivos barril: import { x } from "@/components" trae todos los componentes.

// slow: loads the whole barrel
import { Button } from "@/components";
// fast: loads one module
import { Button } from "@/components/Button";

Otras soluciones: simule con vi.mock los módulos pesados que el test no necesita, evite importar bibliotecas completas de iconos o utilidades y revise el desglose de importaciones en la interfaz de Vitest si su versión lo ofrece. Si un archivo importa 2,000 módulos para probar una sola función, esa importación es el coste real del test.

Ajustes de pool y aislamiento

Vitest ejecuta los archivos de prueba en pools de workers (hilos o procesos bifurcados). La elección y el ajuste de aislamiento intercambian velocidad por seguridad:

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

export default defineConfig({
  test: {
    pool: "threads",     // or "forks" (safer with native modules)
    isolate: false,      // reuse the module graph between files; faster, riskier
  },
});
npx vitest run --pool=threads
npx vitest run --pool=forks
  • forks es más compatible con addons nativos y APIs a nivel de proceso; threads puede arrancar más rápido y consumir menos memoria.
  • isolate: false evita reevaluar las importaciones compartidas en cada archivo, lo que puede reducir mucho el tiempo de importación y de workers. El riesgo es que el estado compartido se filtre entre archivos, así que actívelo solo si sus pruebas no modifican el estado a nivel de módulo ni los globales. Las versiones recientes también permiten ajustes de aislamiento por archivo o por proyecto.
  • El número de workers sigue por defecto los núcleos disponibles. En un runner de 2 vCPU tendrá uno o dos workers, por eso CI parece lento. Configure la opción de número máximo de workers de su versión si tiene más núcleos o menos memoria.

Cambie un ajuste cada vez y compare la línea Duration.

Vitest: encontrar pruebas lentas

Use el reporter verbose para ver las duraciones, y la opción slowTestThreshold para marcar las pruebas lentas (por defecto 300 ms):

test: { slowTestThreshold: 500 }
npx vitest run --reporter=verbose
npx vitest run --reporter=json --outputFile=report.json

Ordene el JSON por duración para obtener las 20 primeras. Con frecuencia las más lentas son pruebas con temporizadores reales, red real o bases de datos reales; use temporizadores falsos (vi.useFakeTimers()) y mocks, o muévalas a un proyecto de integración aparte.

Vitest lento en CI en concreto

Además de los ajustes anteriores:

  • Menos núcleos: los runners de CI son más pequeños que los portátiles. Compare en local con el mismo número de workers.
  • Cachés frías: guarde en caché las dependencias; la caché de transformación de Vite vive en node_modules/.vite, y conservarla puede ayudar en reejecuciones del mismo código.
  • Cobertura: la instrumentación de cobertura puede hacer las ejecuciones mucho más lentas. Ejecute la cobertura en un único trabajo, no en cada shard.
  • Comprobación de tipos: no ejecute el modo typecheck dentro del trabajo principal de pruebas unitarias; ejecute tsc --noEmit en su propio trabajo.

Reparta Vitest entre trabajos

Vitest admite --shard:

strategy:
  fail-fast: false
  matrix:
    shard: [1, 2, 3]
steps:
  - uses: actions/checkout@v4
  - uses: actions/setup-node@v4
    with: { node-version: 22, cache: npm }
  - run: npm ci
  - run: npx vitest run --shard=${{ matrix.shard }}/3 --reporter=blob

Los informes blob de los shards pueden combinarse con vitest --merge-reports, para obtener una salida y una cobertura conjuntas. Los detalles sobre el equilibrio y el coste están en la guía de sharding de pruebas, y el planificador sugiere un número de shards.

Más núcleos

Una vez ajustada la configuración, las suites repartidas en varios archivos escalan con los núcleos. Consulte runners más rápidos de GitHub Actions para ver las opciones. compiler.dev fue en mediana 1.5× más rápido en 18 stacks medidos (15 más rápidos, 2 iguales y 1 más lento) que el runner de 2 núcleos de GitHub, y el modo de comparación mide sus propios jobs. Para todo el pipeline, empiece por el centro de CI lento.

Preguntas frecuentes

¿Por qué Vitest es lento al iniciarse?

Normalmente se debe a la creación del entorno (jsdom), a setupFiles pesados o a un grafo de importaciones grande que se repite en cada archivo. Consulte la línea Duration para saber cuál es el motivo.

¿Por qué Vitest es lento en CI pero rápido en local?

CI tiene menos núcleos, una caché fría y puede ejecutar cobertura o comprobaciones de tipos que en local se omiten.

¿Cómo encuentro los tests lentos en Vitest?

Use --reporter=verbose y slowTestThreshold, o genere una salida JSON y ordénela por duración.

¿Es seguro establecer isolate en false?

Solo si los tests no comparten estado de módulo mutable. Supone una gran mejora de velocidad cuando es seguro; pruébelo en su suite y vigile los fallos que dependan del orden de ejecución.

Ejecute estas pruebas de Vitest en compiler.dev Sin tarjeta · 200 minutos gratuitos

Pruébelo gratis