# Testes Cypress e Playwright instáveis no GitHub Actions: quando a culpa é do executor

> Testes E2E que passam na sua máquina e falham de forma instável no GitHub Actions muitas vezes estão sem recursos: o Cypress, um navegador, o seu app e o banco de dados dividem as 2 CPUs e os 8 GB de um repositório privado. A documentação do Cypress diz que a falta de recursos aparece como falhas instáveis, lentas ou aleatórias. Como confirmar, o que corrigir nos testes, por que os shards custam minutos e um executor com 8 vCPU e 16 GB por $79 fixos por mês.

Testes end-to-end que passam no seu notebook e falham de forma instável no GitHub Actions muitas vezes estão sem recursos, não quebrados. No `ubuntu-latest` de um repositório privado, o Cypress ou o Playwright, um navegador, o servidor do seu app e o banco de dados dividem 2 CPUs e 8 GB, então as páginas renderizam tarde, um comando passa do timeout (4 segundos por padrão no Cypress) ou o navegador trava no meio da execução. A própria documentação do Cypress diz que a falta de recursos aparece como falhas instáveis, lentas ou aparentemente aleatórias, e que o app de exemplo dele roda com folga em 4 vCPUs e 16 GB, o dobro de um executor privado. Confirme observando a CPU e a memória durante uma execução que falha, corrija as esperas fixas e os dados compartilhados nos testes, e dê ao trabalho a máquina de que ele precisa.

O Skipbox dá essa máquina a preço fixo: 8 vCPU e 16 GB com `runs-on: skipbox-8x16` por $79 por mês, em uma máquina que o Skipbox hospeda só para a sua conta, onde os navegadores e os pacotes continuam instalados entre as execuções. Os minutos são ilimitados, então novas tentativas e shards não aumentam a fatura.

- O app de exemplo do Cypress roda com folga em 4 vCPUs e 16 GB; um `ubuntu-latest` privado tem 2 e 8
- 8 vCPU e 16 GB por $79 por mês, com minutos ilimitados
- Os navegadores e os pacotes ficam na sua máquina, então um shard ou uma nova tentativa não os reinstala

**GitHub Actions a preço fixo, minutos ilimitados** O Skipbox roda os seus trabalhos do GitHub Actions na sua própria máquina dedicada: $39 por mês, não importa quantos minutos você rode. As camadas Docker e o cache de dependências ficam entre os trabalhos, então o próximo trabalho começa na hora.

Um executor de 4 vCPU, 20.000 minutos por mês: GitHub $222 → Skipbox $39. Você economiza $183 todo mês.

A mudança é uma linha: `runs-on: skipbox`.

[Começar meu teste grátis de 7 dias](https://app.skipbox.dev/sign-in?ref=g-flaky-e2e-tests-github-actions-pt-br)

## Com o que os testes dividem o executor

Um trabalho E2E roda mais que os testes. Segundo o [guia de desempenho do Cypress](https://docs.cypress.io/app/guides/test-performance), roda o próprio Cypress, o navegador, o servidor do seu app e todos os serviços em segundo plano de que o app depende. No `ubuntu-latest` de um repositório privado, eles dividem 2 CPUs e 8 GB ([executores hospedados pelo GitHub](https://docs.github.com/en/actions/reference/runners/github-hosted-runners)). O de um repositório público tem 4 CPUs e 16 GB, que é o tamanho que o Cypress aponta como confortável para o app de exemplo dele.

Os sinais de uma máquina sem recursos, segundo o mesmo guia:

- Os testes ficam mais lentos conforme a execução avança
- O navegador trava no meio da execução sem uma falha de teste clara
- A CPU ou a memória fica perto de 100% durante a execução

O Playwright inicia um navegador por worker, e [o padrão é metade dos núcleos](https://playwright.dev/docs/api/class-testconfig#test-config-workers). A [documentação de CI](https://playwright.dev/docs/ci#workers) dele recomenda `workers: 1` no CI para priorizar a estabilidade e a reprodutibilidade, de modo que cada teste fique com a máquina inteira, e sugere testes paralelos só em um sistema de CI auto-hospedado potente.

## Confirme antes de mudar qualquer coisa

- **Cypress:** rode com `DEBUG=cypress:server:util:process_profiler npx cypress run`. Ele mostra CPU e memória a cada 10 segundos; CPU constantemente acima de 100% significa que a máquina está saturada.
- **Playwright:** rode de novo a suíte que falha com `--workers=1`. Se as falhas instáveis pararem, o limite era a máquina, não os testes. Guarde o trace na nova tentativa (`trace: 'on-first-retry'`) para ver o que a página estava fazendo quando falhou.
- **Nos dois:** acrescente um step antes dos testes, `nproc && free -h`, e um em segundo plano que registre `top -b -n 1 | head -15` a cada 15 segundos.

As falhas que param numa máquina maior eram do executor, e uma máquina maior acaba com elas. Um teste que continua falhando no mesmo lugar tem um problema próprio: a próxima seção resolve.

## Corrija o que é dos testes

- **Nada de esperas fixas.** `cy.wait(2000)` e `page.waitForTimeout()` passam em um notebook rápido e falham em um executor lento. Espere o elemento, a rota ou a resposta.
- **Registre os intercepts antes da requisição.** Um `cy.intercept` definido depois do clique disputa corrida com a requisição.
- **Isole os dados.** Testes que dividem um usuário ou um registro falham quando rodam em outra ordem ou em paralelo.
- **Ligue as novas tentativas no CI.** O Playwright marca no relatório como instável um teste que falha e depois passa; a configuração `retries` do Cypress roda de novo um teste que falhou no `cypress run`. As novas tentativas mostram quais são instáveis. Elas não os corrigem.

## Quanto custam os shards

Os shards dividem a suíte entre trabalhos, cada um na própria máquina. O [Playwright](https://playwright.dev/docs/test-sharding) aceita `--shard=1/4` e junta os relatórios blob em um trabalho final; o [modo paralelo do Cypress](https://docs.cypress.io/app/continuous-integration/github-actions) exige gravar no Cypress Cloud, que distribui as specs entre as máquinas.

Cada shard é uma VM nova do GitHub: ela instala os pacotes, baixa o navegador (o Playwright desaconselha fazer cache dos navegadores, já que uma restauração leva quase o mesmo tempo que o download), faz o build e sobe o seu app. Quatro shards pagam isso quatro vezes, e a cobrança por minuto conta cada um. Os shards ajudam quando o limite era a máquina, mas multiplicam a configuração junto.

## Quanto custa uma suíte lenta e instável

Os testes E2E são a última verificação antes do merge, então a equipe inteira espera por eles, e uma falha instável acrescenta uma nova execução por cima. Na cobrança por minuto, cada um desses minutos é cobrado:

| Minutos por mês (4 vCPU) | GitHub | Skipbox S | Você economiza por mês |
|---|---|---|---|
| 10.000 | $102 | $39 | **$63** |
| 20.000 | $222 | $39 | **$183** |
| 30.000 | $342 | $39 | **$303** |

Em 8 vCPU, 20.000 minutos custam $422 no GitHub e $79 no Skipbox M. Os valores do GitHub são depois do uso incluído no GitHub Team. Os seus próprios minutos vão na [calculadora da página inicial](https://skipbox.dev/?ref=g-flaky-e2e-tests-github-actions-pt-br#cost).

## Dê a máquina à suíte

Cada plano vem com a máquina dedicada da sua conta, mantida entre os trabalhos, a preço fixo:

| Rótulo | Máquina | Plano |
|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | S, $39 por mês |
| `skipbox-8x16` | 8 vCPU · 16 GB | M, $79 por mês |
| `skipbox-16x32` | 16 vCPU · 32 GB | L, $149 por mês |

- **CPU e memória para a pilha inteira.** O `skipbox-8x16` tem os núcleos e a memória que o Cypress aponta para o app de exemplo dele e mais núcleos, então o navegador, o app e o banco de dados param de disputar. Com 8 vCPU, o padrão do Playwright é de 4 workers.
- **Os navegadores e os pacotes ficam.** Os navegadores do Playwright em `~/.cache/ms-playwright`, o binário do Cypress em `~/.cache/Cypress`, o cache do npm e as imagens Docker dos seus serviços estão no disco quando o próximo trabalho começa.
- **Minutos ilimitados.** Novas tentativas, novas execuções e shards não mudam a fatura. As vCPU dos seus planos definem quantos shards rodam ao mesmo tempo; os shards além disso esperam a vez.

## Mudar é uma linha

```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
```

O `skipbox-8x16` roda em um plano M; o teste roda `runs-on: skipbox` (4 vCPU, 16 GB).

1. Entre no Skipbox com o GitHub.
2. Instale o app do Skipbox no GitHub e escolha os repositórios.
3. Troque o `runs-on` e faça push.

## Segurança

- A máquina é só da sua conta. Nenhum trabalho de outra empresa roda nela.
- Depois de cada trabalho, as credenciais, os processos e os contêineres do executor são apagados. Os navegadores e os caches ficam. Limpar a cada trabalho dá, em vez disso, uma máquina nova a cada trabalho.
- O código de pessoas sem acesso de escrita (como pull requests de forks) roda em uma VM nova que lê os seus caches mas não pode alterá-los.

Os detalhes estão em [como os trabalhos são isolados](https://docs.skipbox.dev/pt-br/isolation).

## Teste na suíte instável

O teste é grátis por 7 dias ou 3.000 minutos de trabalhos, o que vier primeiro, sem cartão. Mova o trabalho E2E para `runs-on: skipbox`, rode-o algumas vezes e compare as falhas instáveis e os tempos de cada step com os do GitHub.

## Perguntas frequentes

### Por que os meus testes Cypress são instáveis no GitHub Actions mas passam na minha máquina?

Muitas vezes porque o executor é menor que o seu notebook. O ubuntu-latest de um repositório privado tem 2 CPUs e 8 GB, e o Cypress, o navegador dele, o servidor do seu app e o banco de dados rodam todos nele. Quando eles disputam recursos, as páginas renderizam tarde, um comando passa do timeout padrão de 4 segundos ou o navegador trava. O próprio guia de desempenho do Cypress diz que a falta de recursos aparece como falhas instáveis, lentas ou aparentemente aleatórias, e que o app de exemplo dele roda com folga em 4 vCPUs e 16 GB. Confirme com DEBUG=cypress:server:util:process_profiler, corrija as esperas fixas e depois dê mais CPU e memória ao trabalho.

### A CPU ou a memória do executor podem ser o motivo de os testes Playwright falharem de forma instável no CI?

Sim. Cada worker do Playwright controla o próprio navegador, e o padrão é metade dos núcleos da máquina. A documentação de CI do Playwright recomenda um worker no CI para ter estabilidade, porque assim cada teste fica com a máquina inteira. Se os testes passam com --workers=1 e falham com mais, o limite é a máquina: fique com um worker em 2 CPUs, ou mude para uma máquina com mais núcleos e memória e aumente os workers lá.

### Como diferenciar um executor sem recursos de um teste instável?

Observe a máquina durante uma execução que falha. O Cypress mostra CPU e memória a cada 10 segundos com DEBUG=cypress:server:util:process_profiler; no Playwright, rode free -h e top em um step em segundo plano, ou rode de novo com --workers=1. Um executor sem recursos mostra CPU perto de 100% ou memória perto do limite, e falhas que mudam de teste e pioram no fim da execução. Um teste instável falha no mesmo lugar também em uma máquina rápida.

### Dividir os testes E2E em shards resolve a instabilidade ou o custo?

Nenhum dos dois sozinho. Os shards dão a cada parte da suíte a própria máquina, o que ajuda quando o limite era a máquina, mas cada shard instala os pacotes, baixa os navegadores e sobe o seu app de novo, e a cobrança por minuto conta cada shard. O modo paralelo do Cypress também exige gravar no Cypress Cloud. No Skipbox, os navegadores e os pacotes ficam na sua máquina e os minutos são ilimitados, então shards e novas tentativas não custam nada a mais.

### Que tamanho de executor os testes E2E devem usar?

Parta do que roda ao lado dos testes: o navegador, o servidor do app e os serviços dele. O app de exemplo do Cypress roda com folga em 4 vCPUs e 16 GB. No Skipbox, runs-on: skipbox-8x16 dá 8 vCPU e 16 GB por $79 por mês, e o skipbox-16x32, 16 vCPU e 32 GB.

### Posso testar de graça?

Sim. O teste dura 7 dias ou 3.000 minutos de trabalhos, o que vier primeiro, sem cartão, com 4 vCPU e 16 GB. Mova o trabalho E2E para runs-on: skipbox, rode-o algumas vezes e compare as falhas e os tempos de cada step com os do GitHub.

Atualizado em 2026-11-19 · https://skipbox.dev/pt-br/guides/flaky-e2e-tests-github-actions
