Perfilado del rendimiento de las pruebas

Cuando ejecutas Vitest, se te proporcionan varias métricas de tiempo de tus pruebas:

RUN  v2.1.1 /x/vitest/examples/profiling

✓ test/prime-number.test.ts (1) 4517ms
  ✓ generate prime number 4517ms

Test Files  1 passed (1)
     Tests  1 passed (1)
  Start at  09:32:53
  Duration  4.80s (transform 44ms, setup 0ms, collect 35ms, tests 4.52s, environment 0ms, prepare 81ms)
  # Time metrics ^^

• Transformación: Tiempo dedicado a transformar los archivos. Consulta Transformación de archivos.
• Configuración: Tiempo empleado en ejecutar los archivos setupFiles.
• Recopilación: Tiempo dedicado a recopilar todas las pruebas en los archivos de prueba. Esto incluye el tiempo de importación de todas las dependencias de los archivos.
• Pruebas: Tiempo dedicado a la ejecución de los casos de prueba.
• Entorno: Tiempo dedicado a configurar el environment de prueba, por ejemplo, JSDOM.
• Preparación: Tiempo que Vitest utiliza para preparar el ejecutor de pruebas.

Ejecutor de pruebas

Si el tiempo de ejecución de tus pruebas es elevado, puedes generar un perfil del ejecutor de pruebas. Consulta la documentación de Node.js para las siguientes opciones:

• --cpu-prof
• --heap-prof
• --prof

WARNING

La opción --prof no funciona con pool: 'threads' debido a las limitaciones de node:worker_threads.

Para pasar estas opciones al ejecutor de pruebas de Vitest, define poolOptions.<pool>.execArgv en tu configuración de Vitest:

Forks

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    pool: 'forks',
    poolOptions: {
      forks: {
        execArgv: [
          '--cpu-prof',
          '--cpu-prof-dir=test-runner-profile',
          '--heap-prof',
          '--heap-prof-dir=test-runner-profile',
        ],

        // Para generar un único perfil
        singleFork: true,
      },
    },
  },
});

Threads

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    pool: 'threads',
    poolOptions: {
      threads: {
        execArgv: [
          '--cpu-prof',
          '--cpu-prof-dir=test-runner-profile',
          '--heap-prof',
          '--heap-prof-dir=test-runner-profile',
        ],

        // Para generar un único perfil
        singleThread: true,
      },
    },
  },
});

Después de que las pruebas se hayan ejecutado, se deberían generar archivos test-runner-profile/*.cpuprofile y test-runner-profile/*.heapprofile. Consulta Inspección de registros de perfilado para obtener instrucciones sobre cómo analizar estos archivos.

Consulta Profiling | Examples para ver un ejemplo.

Hilo principal

Perfilar el hilo principal es útil para depurar el uso de Vite por parte de Vitest y los archivos globalSetup. Aquí también es donde se ejecutan tus plugins de Vite.

TIP

Consulta Performance | Vite para obtener más consejos sobre el perfilado específico de Vite.

Recomendamos vite-plugin-inspect para perfilar el rendimiento de tu plugin de Vite.

Para ello, necesitarás pasar argumentos al proceso de Node.js que ejecuta Vitest.

$ node --cpu-prof --cpu-prof-dir=main-profile ./node_modules/vitest/vitest.mjs --run
#      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                  ^^^^^
#               Argumentos de Node.js                                           Argumentos de Vitest

Después de que las pruebas se hayan ejecutado, se debería generar un archivo main-profile/*.cpuprofile. Consulta Inspección de registros de perfilado para obtener instrucciones sobre cómo analizar este archivo.

Transformación de archivos

Si el tiempo de transformación y recopilación de tus pruebas es elevado, puedes usar la variable de entorno DEBUG=vite-node:* para ver qué archivos están siendo transformados y ejecutados por vite-node.

$ DEBUG=vite-node:* vitest --run

 RUN  v2.1.1 /x/vitest/examples/profiling

  vite-node:server:request /x/vitest/examples/profiling/global-setup.ts +0ms
  vite-node:client:execute /x/vitest/examples/profiling/global-setup.ts +0ms
  vite-node:server:request /x/vitest/examples/profiling/test/prime-number.test.ts +45ms
  vite-node:client:execute /x/vitest/examples/profiling/test/prime-number.test.ts +26ms
  vite-node:server:request /src/prime-number.ts +9ms
  vite-node:client:execute /x/vitest/examples/profiling/src/prime-number.ts +9ms
  vite-node:server:request /src/unnecessary-file.ts +6ms
  vite-node:client:execute /x/vitest/examples/profiling/src/unnecessary-file.ts +4ms
...

Este método de perfilado es una buena forma de identificar transformaciones innecesarias causadas por archivos barril. Si estos registros contienen archivos que no deberían cargarse al ejecutar tu prueba, es posible que tengas archivos barril que importan archivos innecesariamente.

También puedes usar Vitest UI para depurar la lentitud causada por los archivos barril. El ejemplo siguiente muestra cómo importar archivos sin un archivo barril reduce la cantidad de archivos transformados en aproximadamente un 85%.

File tree

├── src
│   └── utils
│       ├── currency.ts
│       ├── formatters.ts  <-- Archivo a probar
│       ├── index.ts
│       ├── location.ts
│       ├── math.ts
│       ├── time.ts
│       └── users.ts
├── test
│   └── formatters.test.ts
└── vitest.config.ts

example.test.ts

import { expect, test } from 'vitest';
import { formatter } from '../src/utils'; 
import { formatter } from '../src/utils/formatters'; 

test('formatter works', () => {
  expect(formatter).not.toThrow();
});

Para observar cómo se transforman los archivos, puedes usar la variable de entorno VITE_NODE_DEBUG_DUMP para escribir los archivos transformados en el sistema de archivos:

$ VITE_NODE_DEBUG_DUMP=true vitest --run

[vite-node] [debug] dump modules to /x/examples/profiling/.vite-node/dump

 RUN  v2.1.1 /x/vitest/examples/profiling
...

$ ls .vite-node/dump/
_x_examples_profiling_global-setup_ts-1292904907.js
_x_examples_profiling_test_prime-number_test_ts-1413378098.js
_src_prime-number_ts-525172412.js

Cobertura de código

Si generar la cobertura de código es lento en tu proyecto, puedes usar la variable de entorno DEBUG=vitest:coverage para habilitar el registro de rendimiento.

$ DEBUG=vitest:coverage vitest --run --coverage

 RUN  v3.1.1 /x/vitest-example

  vitest:coverage Reading coverage results 2/2
  vitest:coverage Converting 1/2
  vitest:coverage 4 ms /x/src/multiply.ts
  vitest:coverage Converting 2/2
  vitest:coverage 552 ms /x/src/add.ts
  vitest:coverage Uncovered files 1/2
  vitest:coverage File "/x/src/large-file.ts" is taking longer than 3s
  vitest:coverage 3027 ms /x/src/large-file.ts
  vitest:coverage Uncovered files 2/2
  vitest:coverage 4 ms /x/src/untested-file.ts
  vitest:coverage Generate coverage total time 3521 ms

Este enfoque de perfilado es excelente para detectar archivos grandes que son seleccionados accidentalmente por los proveedores de cobertura. Por ejemplo, si tu configuración incluye accidentalmente archivos JavaScript minificados de gran tamaño en la cobertura de código, deberían aparecer en los registros. En estos casos, es posible que desees ajustar tus opciones coverage.include y coverage.exclude.

Inspección de registros de perfilado

Puedes inspeccionar el contenido de *.cpuprofile y *.heapprofile con varias herramientas. Consulta la lista a continuación para ver ejemplos.

• Speedscope
• Performance Profiling JavaScript in Visual Studio Code
• Profile Node.js performance with the Performance panel | developer.chrome.com
• Memory panel overview | developer.chrome.com