# Flaky Cypress- en Playwright-tests op GitHub Actions: als de runner de oorzaak is

> E2E-tests die lokaal slagen en op GitHub Actions flaky zijn, krijgen vaak te weinig resources: Cypress, een browser, je app en de database ervan delen de 2 CPU's en 8 GB van een privé-repository. Volgens de documentatie van Cypress uit een tekort aan resources zich als flaky, trage of willekeurige fouten. Hoe je het bevestigt, wat je in de tests oplost, waarom sharden minuten kost, en een runner met 8 vCPU en 16 GB voor een vaste $79 per maand.

End-to-end-tests die op je laptop slagen en op GitHub Actions flaky zijn, krijgen vaak te weinig resources, en zijn niet kapot. Op `ubuntu-latest` van een privé-repository delen Cypress of Playwright, een browser, je appserver en de database ervan 2 CPU's en 8 GB, dus pagina's renderen te laat, een commando loopt over zijn time-out heen (in Cypress standaard 4 seconden), of de browser crasht halverwege de run. Volgens de eigen documentatie van Cypress uit een tekort aan resources zich als flaky, trage of schijnbaar willekeurige fouten, en draait hun voorbeeldapp ruim op 4 vCPU's en 16 GB, twee keer zoveel als een privérunner. Bevestig het door CPU en geheugen te bekijken tijdens een falende run, los vaste wachttijden en gedeelde data in de tests op, en geef de job de machine die hij nodig heeft.

Skipbox geeft hem die machine voor een vaste prijs: 8 vCPU en 16 GB met `runs-on: skipbox-8x16` voor $79 per maand, op de dedicated machine van je account, waar de browsers en packages tussen runs geïnstalleerd blijven. De minuten zijn onbeperkt, dus retries en shards maken de rekening niet hoger.

- De voorbeeldapp van Cypress draait ruim op 4 vCPU's en 16 GB; een privé-`ubuntu-latest` heeft er 2 en 8
- 8 vCPU en 16 GB voor $79 per maand, onbeperkte minuten
- Browsers en packages blijven op je machine, dus een shard of een retry installeert ze niet opnieuw

**GitHub Actions voor een vaste prijs, onbeperkte minuten** Skipbox draait je GitHub Actions-jobs op je eigen dedicated machine: $39 per maand, hoeveel minuten je ook draait. Docker-layers en dependencycaches blijven tussen jobs bewaard, dus de volgende job start meteen.

Een runner met 4 vCPU, 20.000 minuten per maand: GitHub $222 → Skipbox $39. Je bespaart elke maand $183.

Overstappen kost één regel: `runs-on: skipbox`.

[Gratis 7-daagse proefperiode starten](https://app.skipbox.dev/sign-in?ref=g-flaky-e2e-tests-github-actions-nl)

## Waarmee de tests de runner delen

Een E2E-job draait meer dan de tests. Uit de [prestatiegids van Cypress](https://docs.cypress.io/app/guides/test-performance) (in het Engels): Cypress zelf, de browser, je applicatieserver en alle achtergrondservices waar je app van afhangt. Op `ubuntu-latest` van een privé-repository delen ze 2 CPU's en 8 GB ([door GitHub gehoste runners](https://docs.github.com/en/actions/reference/runners/github-hosted-runners)). Die van een openbare repository krijgt 4 CPU's en 16 GB, de grootte die Cypress ruim genoeg noemt voor zijn voorbeeldapp.

De tekenen van een machine met te weinig resources, uit dezelfde gids:

- Tests worden trager naarmate de run vordert
- De browser crasht halverwege de run zonder duidelijke testfout
- CPU of geheugen zit tijdens de run bijna op 100%

Playwright start één browser per worker, en [de standaard is de helft van de cores](https://playwright.dev/docs/api/class-testconfig#test-config-workers). De [CI-documentatie](https://playwright.dev/docs/ci#workers) raadt in CI `workers: 1` aan om stabiliteit en reproduceerbaarheid voorop te zetten, zodat elke test de hele machine krijgt, en stelt parallelle tests alleen voor op een krachtig self-hosted CI-systeem.

## Bevestig het voordat je iets verandert

- **Cypress:** draai met `DEBUG=cypress:server:util:process_profiler npx cypress run`. Het toont elke 10 seconden CPU en geheugen; CPU die steeds boven 100% zit, betekent dat de machine verzadigd is.
- **Playwright:** draai de falende suite opnieuw met `--workers=1`. Stoppen de flakes, dan was de machine de grens, niet de tests. Bewaar de trace bij een retry (`trace: 'on-first-retry'`) om te zien wat de pagina deed toen hij faalde.
- **Allebei:** voeg vóór de tests een step toe, `nproc && free -h`, en een op de achtergrond die elke 15 seconden `top -b -n 1 | head -15` logt.

Flaky fouten die op een grotere machine verdwijnen, kwamen door de runner, en een grotere machine maakt er een eind aan. Een test die nog steeds op dezelfde plek faalt, heeft een probleem in de test zelf: de volgende sectie lost dat op.

## Los op wat bij de tests hoort

- **Geen vaste wachttijden.** `cy.wait(2000)` en `page.waitForTimeout()` slagen op een snelle laptop en falen op een trage runner. Wacht in plaats daarvan op het element, de route of het antwoord.
- **Registreer intercepts vóór het verzoek.** Een `cy.intercept` die na de klik wordt ingesteld, racet met het verzoek.
- **Isoleer data.** Tests die een gebruiker of een record delen, falen als ze in een andere volgorde of parallel draaien.
- **Zet retries aan in CI.** Playwright markeert een test die faalt en daarna slaagt in zijn rapport als flaky; de instelling `retries` van Cypress draait een gefaalde test opnieuw in `cypress run`. Retries laten je de flaky tests zien. Ze lossen ze niet op.

## Wat sharden kost

Sharden verdeelt de suite over jobs, elk op een eigen machine. [Playwright](https://playwright.dev/docs/test-sharding) neemt `--shard=1/4` en voegt de blobrapporten samen in een laatste job; de [parallelle modus van Cypress](https://docs.cypress.io/app/continuous-integration/github-actions) vraagt om opnemen naar Cypress Cloud, dat de specs over machines verdeelt.

Elke shard is een nieuwe GitHub-VM: hij installeert packages, downloadt de browser (Playwright raadt af browsers te cachen, omdat terugzetten ongeveer even lang duurt als downloaden), en bouwt en start je app. Vier shards betalen dat vier keer, en facturering per minuut telt elke shard. Sharden helpt als de machine de grens was, maar het vermenigvuldigt de setup mee.

## Wat een trage, flaky suite kost

E2E-tests zijn de laatste check vóór de merge, dus het hele team wacht erop, en een flake voegt er een herhaalde run aan toe. Bij facturering per minuut wordt elke minuut daarvan gerekend:

| Minuten per maand (4 vCPU) | GitHub | Skipbox S | Je bespaart per maand |
|---|---|---|---|
| 10.000 | $102 | $39 | **$63** |
| 20.000 | $222 | $39 | **$183** |
| 30.000 | $342 | $39 | **$303** |

Op 8 vCPU kosten 20.000 minuten $422 op GitHub en $79 op Skipbox M. De bedragen van GitHub zijn na het inbegrepen gebruik van GitHub Team. Je eigen minuten vul je in bij de [calculator op de startpagina](https://skipbox.dev/?ref=g-flaky-e2e-tests-github-actions-nl#cost).

## Geef de suite de machine

Elk abonnement komt met de dedicated machine van je account, die tussen jobs bewaard blijft, voor een vaste prijs:

| Label | Machine | Abonnement |
|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | S, $39 per maand |
| `skipbox-8x16` | 8 vCPU · 16 GB | M, $79 per maand |
| `skipbox-16x32` | 16 vCPU · 32 GB | L, $149 per maand |

- **CPU en geheugen voor de hele stack.** `skipbox-8x16` heeft de cores en het geheugen die Cypress noemt voor zijn voorbeeldapp, en meer cores, dus de browser, de app en de database concurreren niet meer met elkaar. Met 8 vCPU is de standaard van Playwright 4 workers.
- **Browsers en packages blijven.** De browsers van Playwright in `~/.cache/ms-playwright`, de binary van Cypress in `~/.cache/Cypress`, de cache van npm en de Docker-images van je services staan op de schijf als de volgende job start.
- **Onbeperkte minuten.** Retries, herhaalde runs en shards veranderen de rekening niet. De vCPU van je abonnementen bepalen hoeveel shards er tegelijk draaien; shards daarboven wachten op hun beurt.

## Overstappen kost één regel

```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` draait op een M-abonnement; de proefperiode draait `runs-on: skipbox` (4 vCPU, 16 GB).

1. Log in bij Skipbox met GitHub.
2. Installeer de GitHub-app van Skipbox en kies de repository's.
3. Wijzig `runs-on` en push.

## Beveiliging

- De machine is alleen van je account. Er draaien geen jobs van een ander bedrijf op.
- Na elke job worden de credentials, processen en containers van de runner gewist. De browsers en caches blijven. Met Schone VM per job krijgt elke job in plaats daarvan een nieuwe machine.
- Code van mensen zonder schrijfrechten (zoals pull requests vanuit forks) draait op een nieuwe VM die je caches leest maar niet kan wijzigen.

De details staan in [zo worden jobs geïsoleerd](https://docs.skipbox.dev/nl/isolation).

## Probeer het op de flaky suite

De proefperiode is gratis voor 7 dagen of 3.000 jobminuten, wat het eerst komt, zonder kaart. Zet de E2E-job op `runs-on: skipbox`, draai hem een paar keer, en tel de flakes en de tijden per step tegenover die van GitHub.

## Veelgestelde vragen

### Waarom zijn mijn Cypress-tests flaky op GitHub Actions terwijl ze lokaal slagen?

Vaak omdat de runner kleiner is dan je laptop. ubuntu-latest van een privé-repository heeft 2 CPU's en 8 GB, en Cypress, zijn browser, je appserver en de database ervan draaien er allemaal op. Als ze met elkaar concurreren, renderen pagina's te laat, gaat een commando over zijn standaardtime-out van 4 seconden, of crasht de browser. Volgens de eigen prestatiegids van Cypress uit een tekort aan resources zich als flaky, trage of schijnbaar willekeurige fouten, en draait de voorbeeldapp ruim op 4 vCPU's en 16 GB. Bevestig het met DEBUG=cypress:server:util:process_profiler, los vaste wachttijden op, en geef de job daarna meer CPU en geheugen.

### Kan de CPU of het geheugen van de runner de reden zijn dat Playwright-tests in CI flaky zijn?

Ja. Elke Playwright-worker stuurt zijn eigen browser aan, en standaard is dat de helft van de cores van de machine. De CI-documentatie van Playwright raadt in CI één worker aan voor stabiliteit, omdat elke test dan de hele machine krijgt. Slagen tests met --workers=1 en zijn ze flaky met meer, dan is de machine de grens: houd één worker op 2 CPU's, of stap over op een machine met meer cores en geheugen en verhoog daar het aantal workers.

### Hoe onderscheid ik een runner met te weinig resources van een flaky test?

Kijk naar de machine tijdens een falende run. Cypress toont elke 10 seconden CPU en geheugen met DEBUG=cypress:server:util:process_profiler; draai voor Playwright free -h en top in een step op de achtergrond, of draai opnieuw met --workers=1. Een runner met te weinig resources laat CPU bijna op 100% zien of geheugen bijna op de grens, en fouten die tussen tests verspringen en later in de run erger worden. Een flaky test faalt ook op een snelle machine op dezelfde plek.

### Lost het sharden van E2E-tests flakiness of kosten op?

Op zichzelf geen van beide. Sharden geeft elk deel van de suite een eigen machine, wat helpt als de machine de grens was, maar elke shard installeert packages, downloadt browsers en start je app opnieuw, en facturering per minuut telt elke shard. De parallelle modus van Cypress vraagt ook om opnemen naar Cypress Cloud. Op Skipbox blijven de browsers en packages op je machine en zijn de minuten onbeperkt, dus shards en retries kosten niets extra.

### Welke runnergrootte moeten E2E-tests gebruiken?

Ga uit van waar de tests naast draaien: de browser, de appserver en zijn services. De voorbeeldapp van Cypress draait ruim op 4 vCPU's en 16 GB. Op Skipbox geeft runs-on: skipbox-8x16 8 vCPU en 16 GB voor $79 per maand, en skipbox-16x32 16 vCPU en 32 GB.

### Kan ik het gratis proberen?

Ja. De proefperiode is 7 dagen of 3.000 jobminuten, wat het eerst komt, zonder kaart, op 4 vCPU en 16 GB. Zet de E2E-job op runs-on: skipbox, draai hem een paar keer, en vergelijk de fouten en de tijden per step met die van GitHub.

Bijgewerkt op 2026-11-19 · https://skipbox.dev/nl/guides/flaky-e2e-tests-github-actions
