Saltar al contenido

¿Jest lento? Acelere los tests de Jest: workers y --shard

Última actualización: · Publicada por primera vez:

Si Jest va lento, los principales causantes suelen ser una transformación de TypeScript lenta, demasiados o muy pocos workers, importaciones de módulos pesadas que se repiten en cada archivo de prueba y un único job de CI que ejecuta todo. Esta guía explica cómo acelerar las pruebas de Jest, incluido cómo acelerarlas con TypeScript y cómo funciona el sharding de pruebas de Jest con --shard. Forma parte del clúster de pruebas e2e lentas, que también cubre las pruebas de integración lentas.

Descubra por qué Jest va lento

Empiece por los números.

npx jest --verbose                 # per-test time
npx jest --listTests | wc -l       # how many files
npx jest --logHeapUsage            # memory per test file
npx jest --detectOpenHandles       # why it will not exit

Jest muestra por defecto una advertencia de prueba lenta para las pruebas individuales que superan los cinco segundos. Busque dos patrones: unos pocos archivos muy lentos (corrija esos) o un coste fijo elevado por archivo (carga y transformación de módulos), que afecta a todos los archivos.

Corrija primero la transformación

Las transformaciones con comprobación de tipos son la mayor causa en proyectos de TypeScript. ts-jest comprueba los tipos de cada archivo por defecto. Desactívelo y compruebe los tipos una sola vez con tsc --noEmit en un job aparte, o cambie a un transformador solo de transpilación, como @swc/jest:

// jest.config.js
module.exports = {
  transform: {
    "^.+\\.(t|j)sx?$": ["@swc/jest"],
  },
};

Con ts-jest, establezca isolatedModules: true (o diagnostics: false) para omitir la comprobación de tipos por archivo. Mantenga la comprobación de tipos en CI como un job paralelo independiente, de modo que la corrección no cambie.

Configure los workers de forma deliberada

Jest ejecuta los archivos de prueba en procesos worker paralelos. Por defecto usa los núcleos menos uno. En un runner de CI de 2 vCPU eso equivale a un worker, por lo que la suite se ejecuta en serie. Establézcalo explícitamente:

npx jest --maxWorkers=100%     # all cores, good on a CI runner dedicated to tests
npx jest --maxWorkers=50%      # leaves room for a dev machine
npx jest --runInBand           # one process; can be faster for tiny suites

Para suites muy pequeñas, --runInBand evita el arranque de workers. Para suites grandes, el número adecuado está cerca del número de núcleos. La memoria también importa: si los workers se cierran, reduzca el número o aumente la RAM del runner.

Reduzca la sobrecarga por archivo

  • Archivos barril: importar el index.ts de un paquete puede cargar cientos de módulos. En las pruebas, importe desde el archivo específico.
  • Configuración pesada: mueva la configuración costosa a globalSetup (se ejecuta una vez) en lugar de setupFilesAfterEnv (que se ejecuta antes de cada archivo de prueba).
  • Entorno de pruebas: jsdom tarda más en crearse que node. Use @jest-environment node en las pruebas que no tocan el DOM.
  • Caché: la caché de transformación de Jest está activada por defecto. En CI, guarde en caché el cacheDirectory (npx jest --showConfig | grep cacheDirectory) con actions/cache, usando como clave el lockfile y la configuración. Consulte la caché de GitHub Actions.
  • Solo archivos modificados: --onlyChanged o --changedSince=origin/main ejecuta las pruebas relacionadas con los cambios. Es útil para las comprobaciones de pull request; mantenga una ejecución completa en main.

Sharding de pruebas de Jest

Jest incluye sharding desde la versión 28. --shard=index/count ejecuta una porción de los archivos de prueba:

npx jest --shard=1/4
npx jest --shard=2/4

En GitHub Actions, ejecute una porción por job de la matriz:

jobs:
  jest:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        shard: [1, 2, 3, 4]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: 22, cache: npm }
      - run: npm ci
      - run: npx jest --ci --maxWorkers=100% --shard=${{ matrix.shard }}/4

El sharding se hace por archivo de prueba, no por duración, de modo que un shard puede ser más lento si le tocan los archivos grandes. Si los shards están desequilibrados, divida los archivos grandes o use un divisor basado en duración. La cobertura necesita combinarse; la guía de sharding de pruebas explica cómo, y el planificador estima el número de shards.

Pruebas de integración lentas dentro de Jest

Si las pruebas acceden a una base de datos, haga que sean económicas. Cree el esquema una sola vez en globalSetup, asigne a cada worker su propia base de datos (JEST_WORKER_ID se establece en cada worker) y envuelva cada prueba en una transacción que se revierta. Evite sleep; use jest.useFakeTimers() para la lógica basada en tiempo.

Cuando el cuello de botella es Jest en sí

Algunos equipos migran a Vitest para un arranque más rápido; consulte Vitest lento para saber qué revisar allí, ya que tiene sus propias rutas lentas. La migración es un proyecto, no un indicador, así que corrija primero la transformación y los workers.

Dé más CPU a CI

Las suites de pruebas con muchos archivos escalan con los núcleos. Si los workers están limitados por un runner de 2 vCPU, compare las opciones en runners más rápidos de GitHub Actions. compiler.dev fue en mediana 1.5× más rápido en 18 stacks medidos (15 más rápidos, 2 iguales, 1 más lento) que el runner de 2 núcleos de GitHub, y el modo de comparación mide sus propios jobs. El panorama general está en el centro de CI lento.

Preguntas frecuentes

¿Cómo acelero las pruebas de Jest?

Cambie a una transformación solo de transpilación, configure --maxWorkers para su máquina, reduzca las importaciones por archivo, guarde en caché el directorio de caché de Jest en CI y reparta la ejecución entre jobs con --shard.

¿Cómo acelero las pruebas de Jest con TypeScript?

Use @swc/jest o ts-jest con isolatedModules, y ejecute tsc --noEmit como un job paralelo aparte.

¿Jest admite sharding de pruebas?

Sí, desde Jest 28: jest --shard=1/3. Divide por archivo, así que el equilibrio puede ser desigual.

¿Por qué Jest va más lento en CI que en local?

Hay menos núcleos (y, por tanto, menos workers), la caché de transformación está vacía y a menudo se usa una transformación con comprobación de tipos. Corrija cada una por turno.

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

Pruébelo gratis