Testes Cypress e Playwright instáveis no GitHub Actions: quando a culpa é do executor
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.
Com o que os testes dividem o executor
Um trabalho E2E roda mais que os testes. Segundo o guia de desempenho do Cypress, 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). 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. A documentação de CI 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 registretop -b -n 1 | head -15a 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)epage.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.interceptdefinido 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
retriesdo Cypress roda de novo um teste que falhou nocypress 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 aceita --shard=1/4 e junta os relatórios blob em um trabalho final; o modo paralelo do Cypress 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.
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-8x16tem 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
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).
- Entre no Skipbox com o GitHub.
- Instale o app do Skipbox no GitHub e escolha os repositórios.
- Troque o
runs-one 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.
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 19 de novembro de 2026