Saltar al contenido

Acelere Playwright en un monorepo con GitHub Actions

Última actualización

En un monorepo, Playwright es lento por motivos que no existen en un proyecto con una sola aplicación. Cada shard vuelve a compilar la aplicación, los e2e se ejecutan en pull requests que nunca tocaron la aplicación web y cada job instala el navegador antes de ejecutar un solo test. Para acelerarlo, compile una vez y comparta la compilación, ejecute los e2e solo cuando cambien la aplicación web o algo de lo que depende, y luego divida los tests en shards y combine los informes.

Esta guía trata sobre la estructura de monorepo. Para lo básico de los tests (workers, storageState, esperar lo correcto), lea primero Playwright tests lentos. Para saber cómo funciona el sharding en sí, consulte sharding de tests en GitHub Actions.

Compile una vez, pruebe la compilación

La primera versión habitual de un workflow de Playwright reparte los tests en cuatro jobs, y cada job instala dependencias, compila la aplicación y luego la inicia. La compilación se ejecuta cuatro veces para el mismo commit. Compílela en un solo job y entregue el resultado a los shards:

jobs:
  build:
    runs-on: [self-hosted, Linux, compiler-ci]   # or ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      - uses: pnpm/action-setup@v6
      - uses: actions/setup-node@v7
        with:
          node-version: 22
          cache: pnpm
      - run: pnpm install --frozen-lockfile
      - run: pnpm --filter web... build
      - uses: actions/upload-artifact@v4
        with:
          name: web-build
          path: apps/web/dist
          retention-days: 1

pnpm --filter web... build compila la aplicación web y los paquetes del workspace de los que depende, y nada más. Los ... después del nombre significan «este paquete y sus dependencias». Después, cada shard descarga la compilación y la sirve:

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

export default defineConfig({
  fullyParallel: true,
  reporter: process.env.CI ? [["blob"], ["list"]] : "list",
  webServer: {
    command: "pnpm exec vite preview --port 4173 --strictPort",
    url: "http://localhost:4173",
    reuseExistingServer: !process.env.CI,
  },
});

Sirva la compilación de producción, no un servidor de desarrollo. Un servidor de desarrollo compila los archivos bajo demanda mientras sus tests esperan. Use el equivalente de su framework, como next start para Next.js. El artefacto implica una subida y una descarga, así que compensa cuando la compilación tarda más que eso. Configure retention-days con un valor bajo, porque nadie necesita la compilación de la semana pasada.

Ejecute los e2e solo cuando cambie la aplicación web

En un monorepo, la mayoría de los pull requests modifican una parte del repositorio que su suite e2e no ejercita. Decida en un primer job pequeño si la suite debe ejecutarse:

  changes:
    runs-on: ubuntu-latest
    outputs:
      web: ${{ steps.filter.outputs.web }}
    steps:
      - uses: actions/checkout@v6
      - uses: dorny/paths-filter@v3
        id: filter
        with:
          filters: |
            web:
              - 'apps/web/**'
              - 'packages/ui/**'
              - 'packages/api-client/**'
              - 'pnpm-lock.yaml'

y condicione la compilación y los shards con if: needs.changes.outputs.web == 'true'. La debilidad de una lista de rutas es que se mantiene a mano: cuando apps/web empiece a depender de un paquete nuevo, alguien tendrá que añadirlo. Si sus paquetes declaran bien sus dependencias, deje que pnpm lo determine, como se describe en el CI más rápido para workspaces de pnpm. En cualquier caso, ejecute la suite e2e completa en los push a main, para que una ejecución omitida en un pull request no oculte una rotura durante mucho tiempo.

Mantenga el filtro dentro del workflow, como job, en lugar de en el disparador paths: del workflow. La documentación de GitHub indica que, cuando un filtro de rutas omite un workflow completo, las comprobaciones que debería informar quedan pendientes, por lo que un pull request que las requiere no puede fusionarse. Un job omitido por if: informa éxito.

--only-changed no es un sustituto

Playwright tiene --only-changed. Su texto de ayuda dice que ejecuta solo los archivos de test que cambiaron entre HEAD y una referencia que usted indique, y que necesita Git:

npx playwright test --only-changed=origin/main

Lo probamos en un proyecto pequeño con Playwright 1.63. Selecciona un archivo de test cuando cambia el propio archivo, o cuando cambia un archivo que importa. No conoce su aplicación. Un pull request que cambia app/page.ts, que ningún archivo de test importa, no seleccionó ningún test. Sus tests end-to-end controlan la aplicación a través de un navegador, así que casi todos los cambios de aplicación tienen ese aspecto. Use --only-changed para obtener respuesta rápida mientras escribe tests, o en un pull request que solo edita specs y helpers de test, pero no como red de seguridad. Necesita la rama base en el clon, así que haga checkout con fetch-depth: 0.

Shard y combinación

Con la compilación disponible como artefacto, los jobs de shard solo instalan, descargan y ejecutan tests:

  e2e:
    needs: build
    runs-on: [self-hosted, Linux, compiler-ci]
    strategy:
      fail-fast: false
      matrix:
        shard: [1, 2, 3, 4]
    steps:
      - uses: actions/checkout@v6
      - uses: pnpm/action-setup@v6
      - uses: actions/setup-node@v7
        with:
          node-version: 22
          cache: pnpm
      - run: pnpm install --frozen-lockfile --filter web...
      - uses: actions/download-artifact@v4
        with:
          name: web-build
          path: apps/web/dist
      - run: pnpm --filter web exec playwright install --with-deps chromium
      - run: pnpm --filter web exec playwright test --shard=${{ matrix.shard }}/4
      - uses: actions/upload-artifact@v4
        if: ${{ !cancelled() }}
        with:
          name: blob-report-${{ matrix.shard }}
          path: apps/web/blob-report
          retention-days: 1

  report:
    needs: e2e
    if: ${{ !cancelled() }}
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      - uses: pnpm/action-setup@v6
      - uses: actions/setup-node@v7
        with:
          node-version: 22
          cache: pnpm
      - run: pnpm install --frozen-lockfile --filter web...
      - uses: actions/download-artifact@v4
        with:
          pattern: blob-report-*
          path: all-blob-reports
          merge-multiple: true
      - run: pnpm --filter web exec playwright merge-reports --reporter html ../../all-blob-reports
      - uses: actions/upload-artifact@v4
        with:
          name: playwright-report
          path: apps/web/playwright-report
          retention-days: 7

pnpm install --filter web... instala solo la aplicación web y lo que depende de ella, lo que mantiene corta la instalación de cada shard. El número de shards es un equilibrio entre el tiempo total y el coste fijo que paga cada shard (checkout, instalación, navegador). El planificador de sharding de tests lo estima. Con fullyParallel: true, Playwright divide a nivel de test, lo que reparte los shards mejor que dividir por archivo.

Navegadores y workers

  • Por defecto, Playwright usa aproximadamente la mitad de los núcleos lógicos como workers. La ayuda de la CLI dice «default: 50%». En un runner de 2 vCPU eso es un worker; en 8 vCPU, cuatro. Ajústelo con workers en la configuración o con --workers=75%, y compare el tiempo total y los fallos, porque los navegadores consumen mucho y demasiados workers provocan timeouts.
  • playwright install --with-deps chromium descarga un solo navegador. La documentación de Playwright señala que cachear las descargas de navegadores suele ahorrar poco, ya que restaurar una caché grande puede tardar tanto como descargarla. Mida antes de añadir una caché. Playwright también publica imágenes de contenedor con los navegadores y las bibliotecas del sistema ya instalados; use la etiqueta de imagen que corresponda a la versión de Playwright de su lockfile.

Lo que aportan más núcleos de CPU

El job de tests es la parte que escala con los núcleos, porque los workers ejecutan navegadores en paralelo. La compilación y la instalación no escalan mucho. Así, una máquina más grande ayuda a los jobs de shard y poco a build. Más shards en máquinas pequeñas y menos shards en máquinas grandes son dos formas de pagar el mismo paralelismo, con facturas y costes fijos por shard diferentes. Compare el total de su suite con la calculadora de coste de CI.

Para probar su propia suite, cambie una línea a runs-on: [self-hosted, Linux, compiler-ci], o use el modo de comparación, que ejecuta una copia de sus jobs junto a los actuales. Consulte precios, comparar y nuestros benchmarks. Relacionados: tests de Cypress lentos, tests e2e inestables y el centro de CI lento.

Preguntas frecuentes

¿Cómo compilo la aplicación una vez y la comparto entre los shards de Playwright?

Compile en un job, suba el resultado con actions/upload-artifact y descárguelo en cada job de shard antes de iniciar el servidor web con webServer en la configuración de Playwright.

¿Ejecuta Playwright --only-changed los tests afectados por cambios en la aplicación?

No. Selecciona los archivos de prueba que cambiaron entre HEAD y una referencia, además de los archivos de prueba que importan un archivo modificado. El código de la aplicación que sus pruebas solo alcanzan a través del navegador no se rastrea, así que cambiarlo por sí solo puede no seleccionar ninguna prueba.

¿Cómo omito las pruebas e2e cuando la aplicación web no cambió?

Añada un primer job que compruebe qué rutas cambiaron, con una acción de filtro de rutas (paths filter) o con el selector de paquetes modificados de pnpm, y condicione los jobs de compilación y de shards a su salida mediante if:. No use el disparador paths: a nivel de workflow si las comprobaciones son obligatorias.

¿Cuántos shards de Playwright debe usar un monorepo?

Los suficientes para que el shard más lento no sea mucho más largo que el coste fijo de checkout, instalación y configuración del navegador. A partir de ese punto, más shards solo aumentan el coste.

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

Pruébelo gratis