# Pruebas de Cypress y Playwright inestables en GitHub Actions: cuando la causa es el ejecutor

> Las pruebas E2E que pasan en local y fallan al azar en GitHub Actions suelen estar sin recursos: Cypress, un navegador, tu app y su base de datos comparten los 2 CPU y 8 GB de un repositorio privado. La documentación de Cypress dice que la falta de recursos aparece como fallos inestables, lentos o aleatorios. Cómo confirmarlo, qué corregir en las pruebas, por qué fragmentar cuesta minutos, y un ejecutor con 8 vCPU y 16 GB por $79 fijos al mes.

Las pruebas end-to-end que pasan en tu laptop y fallan al azar en GitHub Actions suelen estar sin recursos, no rotas. En el `ubuntu-latest` de un repositorio privado, Cypress o Playwright, un navegador, el servidor de tu app y su base de datos comparten 2 CPU y 8 GB, así que las páginas se renderizan tarde, un comando supera su tiempo de espera (4 segundos por defecto en Cypress) o el navegador se cae a mitad de la ejecución. La propia documentación de Cypress dice que la falta de recursos aparece como fallos inestables, lentos o aparentemente aleatorios (“presents as flaky, slow, or apparently random failures”) y que su app de ejemplo funciona con holgura con 4 vCPU y 16 GB, el doble que un ejecutor privado. Confírmalo observando la CPU y la memoria durante una ejecución que falla, corrige en las pruebas las esperas fijas y los datos compartidos, y dale al trabajo la máquina que necesita.

Skipbox le da esa máquina a precio fijo: 8 vCPU y 16 GB con `runs-on: skipbox-8x16` por $79 al mes, en una máquina que Skipbox aloja solo para tu cuenta, donde los navegadores y los paquetes se quedan instalados entre ejecuciones. Los minutos son ilimitados, así que los reintentos y los fragmentos no suman a la factura.

- La app de ejemplo de Cypress funciona con holgura con 4 vCPU y 16 GB; un `ubuntu-latest` privado tiene 2 y 8
- 8 vCPU y 16 GB por $79 al mes, con minutos ilimitados
- Los navegadores y los paquetes se quedan en tu máquina, así que un fragmento o un reintento no los reinstala

**GitHub Actions a precio fijo, minutos ilimitados** Skipbox ejecuta tus trabajos de GitHub Actions en tu propia máquina dedicada: $39 al mes, ejecutes los minutos que ejecutes. Las capas de Docker y las cachés de dependencias se conservan entre trabajos, así que el siguiente trabajo empieza enseguida.

Un ejecutor de 4 vCPU, 20.000 minutos al mes: GitHub $222 → Skipbox $39. Ahorras $183 cada mes.

Pasarte lleva una sola línea: `runs-on: skipbox`.

[Empezar mi prueba gratuita de 7 días](https://app.skipbox.dev/sign-in?ref=g-flaky-e2e-tests-github-actions-es)

## Con qué comparten el ejecutor las pruebas

Un trabajo E2E ejecuta más que las pruebas. Según la [guía de rendimiento de Cypress](https://docs.cypress.io/app/guides/test-performance): el propio Cypress, el navegador, el servidor de tu aplicación y cualquier servicio en segundo plano del que dependa tu app (“Cypress itself, the browser, your application server, and any background services your app depends on”). En el `ubuntu-latest` de un repositorio privado comparten 2 CPU y 8 GB ([ejecutores hospedados en GitHub](https://docs.github.com/en/actions/reference/runners/github-hosted-runners)). El de un repositorio público recibe 4 CPU y 16 GB, que es el tamaño que Cypress nombra como holgado para su app de ejemplo.

Las señales de una máquina sin recursos, según la misma guía:

- Las pruebas se vuelven más lentas a medida que avanza la ejecución
- El navegador se cae a mitad de la ejecución sin un fallo claro de una prueba
- La CPU o la memoria se quedan cerca del 100 % durante la ejecución

Playwright inicia un navegador por worker, y [su valor predeterminado es la mitad de los núcleos](https://playwright.dev/docs/api/class-testconfig#test-config-workers). Su [documentación de CI](https://playwright.dev/docs/ci#workers) recomienda `workers: 1` en la CI para priorizar la estabilidad y la reproducibilidad (“to prioritize stability and reproducibility”), así cada prueba tiene la máquina entera, y sugiere pruebas en paralelo solo en un sistema de CI autohospedado potente (“a powerful self-hosted CI system”).

## Confírmalo antes de cambiar nada

- **Cypress:** ejecuta con `DEBUG=cypress:server:util:process_profiler npx cypress run`. Imprime la CPU y la memoria cada 10 segundos; una CPU que se mantiene por encima del 100 % significa que la máquina está saturada.
- **Playwright:** vuelve a ejecutar la suite que falla con `--workers=1`. Si los fallos al azar paran, el límite era la máquina, no las pruebas. Conserva la traza en el reintento (`trace: 'on-first-retry'`) para ver qué hacía la página cuando falló.
- **En los dos:** agrega un paso antes de las pruebas, `nproc && free -h`, y otro en segundo plano que registre `top -b -n 1 | head -15` cada 15 segundos.

Los fallos que desaparecen en una máquina más grande eran del ejecutor, y una máquina más grande los termina. Una prueba que sigue fallando en el mismo sitio tiene un problema propio: la siguiente sección lo arregla.

## Corrige lo que es de las pruebas

- **Sin esperas fijas.** `cy.wait(2000)` y `page.waitForTimeout()` pasan en una laptop rápida y fallan en un ejecutor lento. Espera al elemento, a la ruta o a la respuesta.
- **Registra los intercepts antes de la solicitud.** Un `cy.intercept` configurado después del clic compite con la solicitud.
- **Aísla los datos.** Las pruebas que comparten un usuario o un registro fallan cuando se ejecutan en otro orden o en paralelo.
- **Activa los reintentos en la CI.** Playwright marca como flaky en su informe una prueba que falla y luego pasa; el ajuste `retries` de Cypress vuelve a ejecutar una prueba fallida en `cypress run`. Los reintentos te muestran las inestables. No las arreglan.

## Lo que cuesta fragmentar

Fragmentar reparte la suite entre trabajos, cada uno en su propia máquina. [Playwright](https://playwright.dev/docs/test-sharding) acepta `--shard=1/4` y une los informes blob en un trabajo final; el [modo paralelo de Cypress](https://docs.cypress.io/app/continuous-integration/github-actions) necesita grabar en Cypress Cloud, que reparte los specs entre las máquinas.

Cada fragmento es una VM nueva de GitHub: instala los paquetes, descarga el navegador (Playwright desaconseja guardar los navegadores en caché, porque restaurarlos tarda más o menos lo mismo que descargarlos), compila e inicia tu app. Cuatro fragmentos pagan eso cuatro veces, y la facturación por minuto cuenta cada uno. Fragmentar ayuda cuando el límite era la máquina, pero multiplica con ella la configuración.

## Lo que cuesta una suite lenta e inestable

Las pruebas E2E son la última comprobación antes de fusionar, así que todo el equipo las espera, y un fallo al azar suma una nueva ejecución encima. Con facturación por minuto, cada uno de esos minutos se cobra:

| Minutos al mes (4 vCPU) | GitHub | Skipbox S | Lo que ahorras cada mes |
|---|---|---|---|
| 10.000 | $102 | $39 | **$63** |
| 20.000 | $222 | $39 | **$183** |
| 30.000 | $342 | $39 | **$303** |

Con 8 vCPU, 20.000 minutos cuestan $422 en GitHub y $79 en Skipbox M. Las cifras de GitHub son después del uso incluido en GitHub Team. Tus propios minutos van en la [calculadora de la página de inicio](https://skipbox.dev/?ref=g-flaky-e2e-tests-github-actions-es#cost).

## Dale la máquina a la suite

Cada plan trae la máquina dedicada de tu cuenta, que se mantiene entre trabajos, a precio fijo:

| Etiqueta | Máquina | Plan |
|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | S, $39 al mes |
| `skipbox-8x16` | 8 vCPU · 16 GB | M, $79 al mes |
| `skipbox-16x32` | 16 vCPU · 32 GB | L, $149 al mes |

- **CPU y memoria para todo el stack.** `skipbox-8x16` tiene los núcleos y la memoria que Cypress nombra para su app de ejemplo, y más núcleos, así que el navegador, la app y su base de datos dejan de competir. Con 8 vCPU, el valor predeterminado de Playwright son 4 workers.
- **Los navegadores y los paquetes se quedan.** Los navegadores de Playwright en `~/.cache/ms-playwright`, el binario de Cypress en `~/.cache/Cypress`, la caché de npm y las imágenes de Docker de tus servicios están en el disco cuando empieza el siguiente trabajo.
- **Minutos ilimitados.** Los reintentos, las nuevas ejecuciones y los fragmentos no cambian la factura. Los vCPU de tus planes fijan cuántos fragmentos se ejecutan a la vez; los que pasan de eso esperan su turno.

## Pasarte es una línea

```yaml
jobs:
  e2e:
    runs-on: skipbox-8x16 # was ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      - uses: actions/setup-node@v6
        with:
          node-version: lts/*
      - run: npm ci
      - run: npx playwright install --with-deps
      - run: npx playwright test
```

`skipbox-8x16` se ejecuta en un plan M; la prueba ejecuta `runs-on: skipbox` (4 vCPU, 16 GB).

1. Inicia sesión en Skipbox con GitHub.
2. Instala la app de GitHub de Skipbox y elige los repositorios.
3. Cambia `runs-on` y haz push.

## Seguridad

- La máquina es solo de tu cuenta. Ningún trabajo de otra empresa se ejecuta en ella.
- Después de cada trabajo se borran las credenciales, los procesos y los contenedores del ejecutor. Los navegadores y las cachés se quedan. “VM nueva en cada trabajo” le da a cada trabajo una máquina nueva en su lugar.
- El código de personas sin acceso de escritura (como los pull requests desde forks) se ejecuta en una VM nueva que lee tus cachés pero no puede cambiarlas.

Los detalles están en [cómo se aíslan los trabajos](https://docs.skipbox.dev/es/isolation).

## Pruébalo con la suite inestable

La prueba es gratuita durante 7 días o 3000 minutos de trabajos, lo que ocurra primero, y no pide tarjeta. Pasa el trabajo E2E a `runs-on: skipbox`, ejecútalo varias veces y cuenta los fallos al azar y los tiempos de cada paso frente a los de GitHub.

## Preguntas frecuentes

### ¿Por qué mis pruebas de Cypress fallan al azar en GitHub Actions pero pasan en local?

A menudo porque el ejecutor es más pequeño que tu laptop. El ubuntu-latest de un repositorio privado tiene 2 CPU y 8 GB, y Cypress, su navegador, el servidor de tu app y su base de datos se ejecutan todos ahí. Cuando compiten, las páginas se renderizan tarde, un comando supera su tiempo de espera predeterminado de 4 segundos o el navegador se cae. La propia guía de rendimiento de Cypress dice que la falta de recursos aparece como fallos inestables, lentos o aparentemente aleatorios, y que su app de ejemplo funciona con holgura con 4 vCPU y 16 GB. Confírmalo con DEBUG=cypress:server:util:process_profiler, corrige las esperas fijas y luego dale al trabajo más CPU y memoria.

### ¿Puede la CPU o la memoria del ejecutor ser la razón de que las pruebas de Playwright fallen al azar en la CI?

Sí. Cada worker de Playwright maneja su propio navegador, y el valor predeterminado es la mitad de los núcleos de la máquina. La documentación de CI de Playwright recomienda un solo worker en la CI por estabilidad, porque así cada prueba tiene la máquina entera. Si las pruebas pasan con --workers=1 y fallan con más, el límite es la máquina: deja un solo worker en 2 CPU, o pasa a una máquina con más núcleos y memoria y sube ahí los workers.

### ¿Cómo distingo un ejecutor sin recursos de una prueba inestable?

Observa la máquina durante una ejecución que falla. Cypress imprime la CPU y la memoria cada 10 segundos con DEBUG=cypress:server:util:process_profiler; con Playwright, ejecuta free -h y top en un paso en segundo plano, o vuelve a ejecutar con --workers=1. Un ejecutor sin recursos muestra la CPU cerca del 100 % o la memoria cerca del límite, y fallos que cambian de prueba y empeoran hacia el final de la ejecución. Una prueba inestable falla en el mismo sitio también en una máquina rápida.

### ¿Fragmentar las pruebas E2E resuelve la inestabilidad o el costo?

Ninguna de las dos cosas por sí sola. Fragmentar le da a cada parte de la suite su propia máquina, lo que ayuda cuando el límite era la máquina, pero cada fragmento instala los paquetes, descarga los navegadores e inicia tu app otra vez, y la facturación por minuto cuenta cada fragmento. El modo paralelo de Cypress además necesita grabar en Cypress Cloud. En Skipbox, los navegadores y los paquetes se quedan en tu máquina y los minutos son ilimitados, así que los fragmentos y los reintentos no cuestan nada extra.

### ¿Qué tamaño de ejecutor deberían usar las pruebas E2E?

Empieza por lo que se ejecuta junto a las pruebas: el navegador, el servidor de la app y sus servicios. La app de ejemplo de Cypress funciona con holgura con 4 vCPU y 16 GB. En Skipbox, runs-on: skipbox-8x16 da 8 vCPU y 16 GB por $79 al mes, y skipbox-16x32 16 vCPU y 32 GB.

### ¿Puedo probarlo gratis?

Sí. La prueba dura 7 días o 3000 minutos de trabajos, lo que ocurra primero, sin tarjeta, con 4 vCPU y 16 GB. Pasa el trabajo E2E a runs-on: skipbox, ejecútalo varias veces y compara los fallos y los tiempos de cada paso con los de GitHub.

Actualizado el 2026-11-19 · https://skipbox.dev/es/guides/flaky-e2e-tests-github-actions
