Skipbox

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

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:

  • 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

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.

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

CI/CD mais rápido com um cache sempre aquecido

Seu executor aquecido a preço fixo

Nós hospedamos. Você muda uma linha. 1/12 do custo do GitHub com uso total. Preço fixo, então rode o dia todo. 7× o espaço de cache do GitHub.

  • Sem cartão
  • Entrar com o GitHub
  • Cancele quando quiser