Saltar al contenido

¿Playwright lento en CI? Solucione con workers y sharding

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

Si sus pruebas de Playwright son lentas, la solución normalmente no está en Playwright. Suele deberse a que hay muy pocos workers, a un inicio de sesión repetido en cada prueba, a que los navegadores se descargan en cada ejecución o a un único job secuencial largo. Esta guía muestra cómo acelerar las pruebas de Playwright con configuración real, incluido el sharding de pruebas para Playwright y su equivalente en Python. Forma parte de la guía sobre pruebas e2e lentas.

Por qué la ejecución de pruebas de Playwright es lenta

Mida primero. Ejecute con los reporters list y JSON, y luego ordene por duración:

npx playwright test --reporter=list,json

Divida el tiempo de su job de CI en instalación, instalación del navegador, arranque del servidor y ejecución de pruebas. Si la ejecución de pruebas representa menos de la mitad del total, corrija la preparación antes que las pruebas.

Ejecute archivos y pruebas en paralelo

Playwright ejecuta los archivos de prueba en paralelo de forma predeterminada, pero las pruebas dentro de un mismo archivo se ejecutan en orden. Configure fullyParallel para ejecutar todas las pruebas en paralelo, y defina los workers de forma explícita en CI:

// playwright.config.ts
import { defineConfig } from "@playwright/test";

export default defineConfig({
  fullyParallel: true,
  workers: process.env.CI ? 4 : undefined,
  retries: process.env.CI ? 1 : 0,
  use: { trace: "on-first-retry" },
  reporter: process.env.CI ? [["blob"], ["list"]] : "list",
});

De forma predeterminada, Playwright usa aproximadamente la mitad de los núcleos lógicos de CPU. En un runner de 2 vCPU eso significa un solo worker, por lo que un runner pequeño hace que Playwright parezca lento. No configure un número de workers muy superior al de núcleos: los navegadores consumen muchos recursos y una CPU sobrecargada provoca timeouts que parecen inestabilidad.

Inicie sesión una vez con storageState

Iniciar sesión a través de la interfaz antes de cada prueba es el desperdicio más habitual. Inicie sesión una vez en un proyecto de setup y reutilice el estado guardado:

projects: [
  { name: "setup", testMatch: /auth\.setup\.ts/ },
  {
    name: "chromium",
    use: { storageState: "playwright/.auth/user.json" },
    dependencies: ["setup"],
  },
],

Cargue los datos de prueba a través de su API o su base de datos en lugar de hacerlo mediante la interfaz. Si sus pruebas necesitan usuarios únicos por worker, créelos en un fixture con alcance de worker.

Deje de esperar por tiempo

Elimine page.waitForTimeout(). Use aserciones web-first con auto-espera, como await expect(page.getByRole("button", { name: "Save" })).toBeEnabled(). Espere una respuesta concreta con page.waitForResponse cuando la interfaz dependa de una petición. Bloquee lo que no necesite, como analíticas y fuentes, con page.route, para reducir el tiempo de carga de la página.

Inicie la aplicación una sola vez

Use la opción webServer para que Playwright inicie la aplicación una sola vez durante toda la ejecución, y en CI ejecute una compilación de producción en lugar de un servidor de desarrollo, que compila bajo demanda:

webServer: {
  command: "npm run start",
  url: "http://localhost:3000",
  reuseExistingServer: !process.env.CI,
},

Sharding de pruebas con Playwright

El sharding reparte la suite entre varios jobs. Playwright lo incluye de forma nativa con --shard=x/y. Use el reporter blob para que los informes puedan combinarse después:

jobs:
  e2e:
    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 playwright install --with-deps chromium
      - run: npx playwright test --shard=${{ matrix.shard }}/4
      - uses: actions/upload-artifact@v4
        if: ${{ !cancelled() }}
        with:
          name: blob-report-${{ matrix.shard }}
          path: blob-report
  merge:
    needs: e2e
    if: ${{ !cancelled() }}
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: 22, cache: npm }
      - run: npm ci
      - uses: actions/download-artifact@v4
        with: { path: all-blob-reports, pattern: blob-report-*, merge-multiple: true }
      - run: npx playwright merge-reports --reporter html ./all-blob-reports

Número de shards: use el planificador de sharding de pruebas para estimar el tiempo total y el coste, y consulte la guía de sharding para equilibrar la carga. Con fullyParallel: true, Playwright equilibra a nivel de prueba, lo que produce shards más uniformes que dividir por archivos.

Instale solo el navegador que necesite

npx playwright install --with-deps chromium descarga un único navegador en lugar de tres. La documentación de Playwright señala que cachear las descargas de navegadores suele ahorrar poco, porque restaurar una caché grande tarda casi lo mismo que descargarla; mida antes de añadirla. Como alternativa, ejecute en la imagen de contenedor oficial de Playwright, donde ya están presentes los navegadores y las dependencias del sistema.

Acelere Playwright con Python

El paquete de Python usa pytest. Ejecute en paralelo con pytest-xdist y reutilice el estado autenticado con un fixture de alcance de sesión:

pip install pytest-playwright pytest-xdist
pytest -n 4 --browser chromium

Cada worker de xdist es un proceso independiente con su propio navegador, por lo que los datos deben aislarse por worker. Reparta las pruebas de Python entre jobs con los enfoques de pruebas lentas de pytest. Reutilice el inicio de sesión guardando context.storage_state(path="state.json") una sola vez y pasando storage_state a browser.new_context.

Dé más CPU a los navegadores

Cuando los workers esperan en cola detrás de dos núcleos, el hardware es la siguiente palanca. Consulte runners más rápidos de GitHub Actions. Si prueba compiler.dev, su modo de comparación ejecuta sus propios jobs, lo que importa porque las mejoras de velocidad en pruebas de navegador dependen de su suite. Fue un 1.5× más rápido de mediana en 18 stacks medidos (15 más rápidos, 2 iguales, 1 más lento) que el runner de 2 núcleos de GitHub.

En un monorepo, compile la aplicación una vez y compártala entre shards: acelerar Playwright en un monorepo. Pruebas e2e inestables explica por qué los reintentos y las suites lentas suelen ir de la mano; Cypress lento en pruebas es la guía hermana si usa ambas herramientas; el centro de CI lento cubre el resto del pipeline.

Preguntas frecuentes

¿Cómo acelero las pruebas de Playwright?

Use fullyParallel, ajuste los workers al número de núcleos, inicie sesión una vez con storageState, elimine las esperas fijas, inicie la aplicación una sola vez y reparta las pruebas entre jobs con --shard.

¿Cuántos workers debería usar Playwright en CI?

Aproximadamente uno por núcleo para aplicaciones más ligeras, y menos para las pesadas. Mida el tiempo total y la tasa de fallos con 1, 2 y 4 workers.

¿Cómo funciona el sharding de Playwright?

--shard=2/4 ejecuta el segundo de cuatro fragmentos de la suite. Ejecute cada fragmento en su propio job y combine después los informes blob.

¿Por qué mis pruebas de Playwright son más lentas en CI?

Las máquinas de CI tienen menos núcleos, cachés frías y un navegador recién instalado. Compare el número de workers y el tiempo de preparación con su ejecución local.

Ejecute estos tests de Playwright en compiler.dev Sin tarjeta · 200 minutos gratuitos

Pruébelo gratis