# Test Cypress e Playwright instabili su GitHub Actions: quando la causa è il runner

> I test E2E che passano in locale e falliscono a caso su GitHub Actions spesso sono a corto di risorse: Cypress, un browser, la tua app e il suo database si dividono le 2 CPU e gli 8 GB di un repository privato. La documentazione di Cypress dice che la carenza di risorse si presenta come errori instabili, lenti o casuali. Come confermarlo, cosa correggere nei test, perché lo sharding costa minuti, e un runner con 8 vCPU e 16 GB a un prezzo fisso di $79 al mese.

I test end-to-end che passano sul tuo laptop e falliscono a caso su GitHub Actions spesso sono a corto di risorse, non rotti. Sull'`ubuntu-latest` di un repository privato, Cypress o Playwright, un browser, il server della tua app e il suo database si dividono 2 CPU e 8 GB, quindi le pagine si disegnano tardi, un comando supera il suo timeout (4 secondi di default in Cypress), o il browser va in crash a metà. La documentazione di Cypress dice che la carenza di risorse "presents as flaky, slow, or apparently random failures" e che la sua app di esempio gira comoda su 4 vCPU e 16 GB, il doppio di un runner privato. Confermalo osservando CPU e memoria durante un'esecuzione che fallisce, correggi nei test le attese fisse e i dati condivisi, e dai al job la macchina che gli serve.

Skipbox gli dà quella macchina a un prezzo fisso: 8 vCPU e 16 GB con `runs-on: skipbox-8x16` per $79 al mese, sulla macchina del tuo account, dove browser e pacchetti restano installati tra un'esecuzione e l'altra. I minuti sono illimitati, quindi retry e shard non si aggiungono alla fattura.

- L'app di esempio di Cypress gira comoda su 4 vCPU e 16 GB; un `ubuntu-latest` privato ne ha 2 e 8
- 8 vCPU e 16 GB per $79 al mese, minuti illimitati
- Browser e pacchetti restano sulla tua macchina, quindi uno shard o un retry non li reinstalla

**GitHub Actions a prezzo fisso, minuti illimitati** Skipbox esegue i tuoi job di GitHub Actions su una macchina dedicata tutta tua: $39 al mese, per quanti minuti tu esegua. I layer Docker e le cache delle dipendenze restano tra un job e l'altro, così il job successivo parte subito.

Un runner da 4 vCPU, 20.000 minuti al mese: GitHub $222 → Skipbox $39. Risparmi $183 ogni mese.

Per passare basta una riga: `runs-on: skipbox`.

[Inizia la prova gratuita di 7 giorni](https://app.skipbox.dev/sign-in?ref=g-flaky-e2e-tests-github-actions-it)

## Con cosa dividono il runner i test

Un job E2E esegue più dei test. Dalla [guida alle prestazioni di Cypress](https://docs.cypress.io/app/guides/test-performance): "Cypress itself, the browser, your application server, and any background services your app depends on". Sull'`ubuntu-latest` di un repository privato si dividono 2 CPU e 8 GB ([runner ospitati da GitHub](https://docs.github.com/en/actions/reference/runners/github-hosted-runners)). Quello di un repository pubblico ha 4 CPU e 16 GB, la dimensione che Cypress indica come comoda per la sua app di esempio.

I segni di una macchina a corto di risorse, dalla stessa guida:

- I test diventano più lenti man mano che l'esecuzione va avanti
- Il browser va in crash a metà esecuzione senza un errore di test chiaro
- CPU o memoria restano vicine al 100% durante l'esecuzione

Playwright avvia un browser per worker, e [il suo valore predefinito è metà dei core](https://playwright.dev/docs/api/class-testconfig#test-config-workers). La sua [documentazione per la CI](https://playwright.dev/docs/ci#workers) consiglia `workers: 1` in CI "to prioritize stability and reproducibility", così ogni test ha tutta la macchina, e suggerisce test paralleli solo su "a powerful self-hosted CI system".

## Confermalo prima di cambiare qualcosa

- **Cypress:** esegui con `DEBUG=cypress:server:util:process_profiler npx cypress run`. Stampa CPU e memoria ogni 10 secondi; una CPU costantemente sopra il 100% vuol dire che la macchina è satura.
- **Playwright:** riesegui la suite che fallisce con `--workers=1`. Se gli errori a caso smettono, il limite era la macchina, non i test. Tieni la trace al retry (`trace: 'on-first-retry'`) per vedere cosa faceva la pagina quando ha fallito.
- **Entrambi:** aggiungi uno step prima dei test, `nproc && free -h`, e uno in background che registra `top -b -n 1 | head -15` ogni 15 secondi.

I fallimenti intermittenti che spariscono su una macchina più grande dipendevano dal runner, e una macchina più grande li elimina. Un test che fallisce ancora nello stesso punto ha un problema suo: la sezione successiva lo risolve.

## Correggi quello che spetta ai test

- **Niente attese fisse.** `cy.wait(2000)` e `page.waitForTimeout()` passano su un laptop veloce e falliscono su un runner lento. Aspetta invece l'elemento, la route o la risposta.
- **Registra gli intercept prima della richiesta.** Un `cy.intercept` impostato dopo il clic fa a gara con la richiesta.
- **Isola i dati.** I test che condividono un utente o un record falliscono quando girano in un altro ordine o in parallelo.
- **Attiva i retry in CI.** Playwright segna come flaky nel suo report un test che fallisce e poi passa; l'impostazione `retries` di Cypress riesegue un test fallito in `cypress run`. I retry ti mostrano quelli instabili. Non li correggono.

## Quanto costa lo sharding

Lo sharding divide la suite su più job, ognuno sulla sua macchina. [Playwright](https://playwright.dev/docs/test-sharding) accetta `--shard=1/4` e unisce i blob report in un job finale; la [modalità parallela di Cypress](https://docs.cypress.io/app/continuous-integration/github-actions) richiede la registrazione su Cypress Cloud, che distribuisce le spec tra le macchine.

Ogni shard è una nuova VM di GitHub: installa i pacchetti, scarica il browser (Playwright sconsiglia di mettere in cache i browser, perché un ripristino dura più o meno quanto il download), costruisce e avvia la tua app. Quattro shard pagano tutto questo quattro volte, e la fatturazione al minuto li conta tutti. Lo sharding aiuta quando il limite era la macchina, ma con lei moltiplica la preparazione.

## Quanto costa una suite lenta e instabile

I test E2E sono l'ultimo controllo prima del merge, quindi tutto il team li aspetta, e un errore a caso aggiunge una riesecuzione. Con la fatturazione al minuto ognuno di quei minuti si paga:

| Minuti al mese (4 vCPU) | GitHub | Skipbox S | Risparmi ogni mese |
|---|---|---|---|
| 10.000 | $102 | $39 | **$63** |
| 20.000 | $222 | $39 | **$183** |
| 30.000 | $342 | $39 | **$303** |

A 8 vCPU, 20.000 minuti costano $422 su GitHub e $79 su Skipbox M. Le cifre di GitHub sono al netto dell'uso incluso in GitHub Team. I tuoi minuti vanno nel [calcolatore della home](https://skipbox.dev/?ref=g-flaky-e2e-tests-github-actions-it#cost).

## Dai alla suite la macchina

Ogni piano include la macchina del tuo account, che resta tra un job e l'altro, a un prezzo fisso:

| Etichetta | Macchina | Piano |
|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | S, $39 al mese |
| `skipbox-8x16` | 8 vCPU · 16 GB | M, $79 al mese |
| `skipbox-16x32` | 16 vCPU · 32 GB | L, $149 al mese |

- **CPU e memoria per tutto lo stack.** `skipbox-8x16` ha i core e la memoria che Cypress indica per la sua app di esempio e più core ancora, quindi il browser, l'app e il suo database smettono di contendersi le risorse. Con 8 vCPU, il valore predefinito di Playwright è 4 worker.
- **Browser e pacchetti restano.** I browser di Playwright in `~/.cache/ms-playwright`, il binario di Cypress in `~/.cache/Cypress`, la cache di npm e le immagini Docker dei tuoi servizi sono sul disco quando parte il job successivo.
- **Minuti illimitati.** Retry, riesecuzioni e shard non cambiano la fattura. Le vCPU dei tuoi piani stabiliscono quanti shard girano insieme; gli shard oltre quel numero aspettano il loro turno.

## Basta una riga

```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` gira su un piano M; la prova esegue `runs-on: skipbox` (4 vCPU, 16 GB).

1. Accedi a Skipbox con GitHub.
2. Installa la GitHub App di Skipbox e scegli i repository.
3. Cambia `runs-on` e fai push.

## Sicurezza

- La macchina è solo del tuo account. Nessun job di altre aziende gira su di essa.
- Dopo ogni job vengono cancellati le credenziali, i processi e i container del runner. Browser e cache restano. “VM nuova per ogni job” dà invece a ogni job una macchina nuova.
- Il codice di chi non ha accesso in scrittura (come le pull request dai fork) gira su una VM nuova che legge le tue cache ma non le può modificare.

I dettagli sono in [come vengono isolati i job](https://docs.skipbox.dev/it/isolation).

## Provalo sulla suite instabile

La prova è gratuita per 7 giorni o 3000 minuti di job, quello che arriva prima, senza carta. Sposta il job E2E su `runs-on: skipbox`, eseguilo qualche volta e conta errori a caso e tempi degli step rispetto a quelli di GitHub.

## Domande frequenti

### Perché i miei test Cypress sono instabili su GitHub Actions ma passano in locale?

Spesso perché il runner è più piccolo del tuo laptop. L'ubuntu-latest di un repository privato ha 2 CPU e 8 GB, e su di esso girano Cypress, il suo browser, il server della tua app e il suo database. Quando si contendono le risorse, le pagine si disegnano tardi, un comando supera il suo timeout predefinito di 4 secondi, o il browser va in crash. La guida alle prestazioni di Cypress dice che la carenza di risorse si presenta come errori instabili, lenti o apparentemente casuali, e che la sua app di esempio gira comoda su 4 vCPU e 16 GB. Confermalo con DEBUG=cypress:server:util:process_profiler, correggi le attese fisse, poi dai al job più CPU e più memoria.

### CPU o memoria del runner possono essere il motivo per cui i test Playwright falliscono a caso in CI?

Sì. Ogni worker di Playwright guida il suo browser, e il valore predefinito è metà dei core della macchina. La documentazione di Playwright per la CI consiglia un worker in CI per la stabilità, perché così ogni test ha tutta la macchina. Se i test passano con --workers=1 e falliscono con di più, il limite è la macchina: tieni un worker su 2 CPU, o passa a una macchina con più core e memoria e lì alza i worker.

### Come distinguo un runner a corto di risorse da un test instabile?

Osserva la macchina durante un'esecuzione che fallisce. Cypress stampa CPU e memoria ogni 10 secondi con DEBUG=cypress:server:util:process_profiler; per Playwright, esegui free -h e top in uno step in background, o riesegui con --workers=1. Un runner a corto di risorse mostra la CPU vicina al 100% o la memoria vicina al limite, ed errori che si spostano da un test all'altro e peggiorano verso la fine dell'esecuzione. Un test instabile fallisce nello stesso punto anche su una macchina veloce.

### Lo sharding dei test E2E risolve l'instabilità o il costo?

Nessuno dei due, da solo. Lo sharding dà a ogni parte della suite la sua macchina, il che aiuta quando il limite era la macchina, ma ogni shard installa di nuovo i pacchetti, scarica i browser e avvia la tua app, e la fatturazione al minuto conta ogni shard. La modalità parallela di Cypress richiede anche la registrazione su Cypress Cloud. Su Skipbox browser e pacchetti restano sulla tua macchina e i minuti sono illimitati, quindi shard e retry non costano niente in più.

### Che dimensione di runner devono usare i test E2E?

Parti da quello che gira accanto ai test: il browser, il server dell'app e i suoi servizi. L'app di esempio di Cypress gira comoda su 4 vCPU e 16 GB. Su Skipbox, runs-on: skipbox-8x16 dà 8 vCPU e 16 GB per $79 al mese, e skipbox-16x32 16 vCPU e 32 GB.

### Posso provarlo gratis?

Sì. La prova dura 7 giorni o 3000 minuti di job, quello che arriva prima, senza carta, su 4 vCPU e 16 GB. Sposta il job E2E su runs-on: skipbox, eseguilo qualche volta e confronta errori e tempi degli step con quelli di GitHub.

Aggiornata il giorno 2026-11-16 · https://skipbox.dev/it/guides/flaky-e2e-tests-github-actions
