Estratégia de cobertura e CI

Como decidir o que testar em cada nível, interpretar a cobertura sem se enganar e fazer a CI rodar a suíte com relatórios confiáveis.

Cerca de 16 min · Revisado em

Ao final, você vai conseguir

  • Comparar pirâmide e troféu de testes e reconhecer uma suíte desequilibrada
  • Priorizar o que automatizar usando risco e frequência
  • Explicar por que 100% de cobertura não garante ausência de bugs
  • Montar um workflow que roda testes em jobs e shards e guarda relatórios como artefatos
  • Tratar testes instáveis com quarentena e diferenciar bug do produto, falha do teste e falha de ambiente

Uma equipe com 900 testes pode estar menos protegida que outra com 200. Se a suíte leva 40 minutos, falha “de vez em quando” e ninguém sabe o que ela cobre, as pessoas param de olhar para o vermelho, e é aí que o bug passa. Decidir o que testar, em que nível, e como a CI mostra o resultado é o que transforma testes soltos em uma rede de segurança de verdade. É também uma das perguntas favoritas em entrevistas de QA: “como você montaria a estratégia de testes deste produto?”.

Quantos testes de cada tipo

Na aula de testes de interface você viu a pirâmide de testes: muitos testes de unidade na base, vários de integração no meio e poucos de ponta a ponta no topo. Um teste de integração confere duas ou mais peças conversando de verdade, como a API com o banco, ou uma tela com o roteador e o formulário.

Modelo

Pirâmide

Base larga de testes de unidade, rápidos e baratos; poucos E2E no topo. Ótima regra para regras de negócio e serviços de backend.

  • Unidade: maioria
  • Integração: vários
  • Ponta a ponta: poucos

Modelo

Troféu

Popular no frontend: a maior parte do esforço em testes de integração, que dão mais confiança por teste, apoiados por análise estática (TypeScript e lint).

  • Estático: sempre ligado
  • Unidade: lógica isolada
  • Integração: a maior fatia
  • Ponta a ponta: poucos

Os dois modelos concordam no essencial: poucos testes de ponta a ponta, só nas jornadas críticas, e a maior parte das conferências nos níveis mais rápidos. O desenho que eles condenam é o sorvete de casquinha: quase tudo em E2E e testes manuais, quase nada embaixo.

Uma equipe tem 15 testes de unidade e 400 testes de ponta a ponta. A suíte leva 50 minutos e falha em média uma vez por dia sem bug real. Qual o melhor primeiro passo?

  • Levar as regras que estão sendo conferidas pelo navegador para testes de unidade e de API, mantendo E2E só nas jornadas críticas
  • Comprar máquinas mais rápidas para a CI
  • Configurar 3 tentativas automáticas para todos os testes
  • Apagar os testes que falham com frequência

O que vale automatizar

Automatizar custa: escrever, manter e esperar o teste rodar. O retorno vem quando ele roda muitas vezes e protege algo que importa. Duas perguntas resolvem a maioria das dúvidas: qual o risco se isso quebrar? E com que frequência isso precisa ser conferido?

Risco e frequência, as duas perguntas da aula de técnicas e riscos aplicadas à automação
Muda ou roda com frequênciaRaramente
Risco altoAutomatize primeiro (login, pagamento, cálculo de preço)Automatize o essencial e explore manualmente
Risco baixoAutomatize se for barato, em nível baixoConfira manualmente ou só observe

Para cada caso, o melhor caminho é automatizar ou manter como verificação manual/exploratória?

Automatizar · Manual ou exploratório

  • Pagamento com Pix no checkout, conferido a cada deploy
  • As 20 regras de cálculo de frete por faixa de CEP
  • Pessoa sem login não consegue ver pedidos de outras pessoas
  • A tela de cadastro continua funcionando depois de cada mudança
  • Avaliar se o novo layout da home ficou fácil de entender
  • Banner de uma campanha que fica no ar só neste fim de semana
  • Primeira investigação de um recurso que acabou de ser criado

O que a cobertura mede, e o que não mede

Cobertura de código é a porcentagem do código que foi executada enquanto os testes rodavam. A cobertura de linhas conta quais linhas rodaram; a de ramos (branches) conta se cada caminho de um if foi seguido, tanto o “sim” quanto o “não”.

Meça a cobertura de um projeto

O projeto usa Vitest para testes de unidade. Rode os testes, peça o relatório de cobertura e veja o que acontece com uma meta mínima.

  1. Rode os testes de unidade: npx vitest run

    npx vitest run
     ✓ src/carrinho.test.ts (8 tests) 12ms
     ✓ src/frete.test.ts (4 tests) 5ms
     ✓ src/cupom.test.ts (2 tests) 4ms
    
     Test Files  3 passed (3)
          Tests  14 passed (14)
       Duration  612ms
  2. Agora peça o relatório de cobertura: npx vitest run --coverage

    npx vitest run --coverage
     ✓ src/carrinho.test.ts (8 tests) 12ms
     ✓ src/frete.test.ts (4 tests) 5ms
     ✓ src/cupom.test.ts (2 tests) 4ms
    
     Test Files  3 passed (3)
          Tests  14 passed (14)
    
     % Coverage report from v8
    -------------|---------|----------|---------|---------|-------------------
    File         | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
    -------------|---------|----------|---------|---------|-------------------
    All files    |   86.95 |    72.72 |   88.88 |   86.95 |
     carrinho.ts |     100 |      100 |     100 |     100 |
     cupom.ts    |   63.63 |       40 |      75 |   63.63 | 14-19
     frete.ts    |     100 |      100 |     100 |     100 |
    -------------|---------|----------|---------|---------|-------------------
  3. Simule a meta que a CI cobra, de 80% de ramos: npx vitest run --coverage --coverage.thresholds.branches=80

    npx vitest run --coverage --coverage.thresholds.branches=80
     Test Files  3 passed (3)
          Tests  14 passed (14)
    
     % Coverage report from v8
     All files    |   86.95 |    72.72 |   88.88 |   86.95 |
    
    ERROR: Coverage for branches (72.72%) does not meet global threshold (80%)

O relatório é ótimo para achar o que nenhum teste executa: as linhas 14 a 19 do cupom.ts, por exemplo, nunca rodaram. Mas ele não diz se os testes que rodaram conferem alguma coisa. Uma linha pode ser executada por um teste sem nenhum expect.

O frete.ts tem 100% de cobertura de linhas e de ramos. Uma pessoa da equipe diz: “então o frete não tem bug”. Ela está certa?

  • Não. Cobertura mostra que o código rodou, não que o resultado foi conferido nem que os casos certos foram testados
  • Sim. Se todas as linhas e ramos rodaram, todo comportamento foi testado
  • Sim, desde que a cobertura de ramos também seja 100%
  • Não, porque cobertura só vale para testes de ponta a ponta

Uma forma de medir se os testes realmente conferem algo é o teste de mutação: uma ferramenta cria cópias do código com pequenos defeitos (os mutantes), como trocar >= por >, e roda os testes em cada uma. Mutante que sobrevive mostra uma conferência que está faltando.

Cobertura de 100% e mutantes que escapam

Os dois testes em testar já executam todas as linhas de frete: cobertura de 100%. Mesmo assim, dois mutantes escapam. Acrescente assert nos valores de fronteira até todos os mutantes serem pegos e a regra correta continuar passando.

# Regra da loja: a partir de R$ 100, frete grátis; abaixo disso, R$ 12
def frete(total):
    if total >= 100:
        return 0
    return 12

# Mutantes: cópias com um pequeno defeito, como os que escapam numa revisão apressada
def mutante_maior(total):
    if total > 100:
        return 0
    return 12

def mutante_99(total):
    if total >= 99:
        return 0
    return 12

def mutante_valor(total):
    if total >= 100:
        return 0
    return 15

# Seus testes: recebem uma função de frete e conferem com assert
def testar(f):
    assert f(150) == 0
    assert f(50) == 12
    # Acrescente aqui casos na fronteira da regra

# Placar (não precisa mexer)
def pega(f):
    try:
        testar(f)
    except Exception:
        return True
    return False

print('Regra correta passa:', not pega(frete))
for m in [mutante_maior, mutante_99, mutante_valor]:
    print(m.__name__, '->', 'pegou' if pega(m) else 'escapou')
  • Seus testes passam com a regra correta
  • Pega o mutante que trocou >= por >
  • Pega o mutante que começa o frete grátis em R$ 99
  • Pega o mutante que cobra R$ 15

A suíte rodando na CI

Na aula de CI e publicação você montou um workflow que roda lint, testes e build a cada push. Para uma suíte de testes de verdade, entram três peças novas: separar os testes em jobs (blocos de trabalho que podem rodar ao mesmo tempo), guardar artefatos (arquivos produzidos pela execução, como relatórios e traces) e dividir os testes lentos entre máquinas.

Um workflow do GitHub Actions com testes de unidade e de ponta a ponta. Explore as partes.

name: Testes
on: [push, pull_request]

jobs:
  unidade:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: 22, cache: npm }
      - run: npm ci
      - run: npx vitest run --coverage

  e2e:
    needs: unidade
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        shard: [1/3, 2/3, 3/3]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: 22, cache: npm }
      - run: npm ci
      - run: npx playwright install --with-deps chromium
      - run: npx playwright test --shard=${{ matrix.shard }}
      - uses: actions/upload-artifact@v4
        if: ${{ !cancelled() }}
        with:
          name: relatorio-${{ strategy.job-index }}
          path: playwright-report/
          retention-days: 14
  • Job rápido: Os testes de unidade e integração rodam primeiro, num job próprio. Em poucos minutos a pessoa já sabe se quebrou alguma regra.
  • Cobertura como sinal: O relatório de cobertura sai junto. Uma meta mínima pode quebrar o job, mas use como alarme para partes importantes sem teste, não como nota.
  • Dependência entre jobs: O job de ponta a ponta só começa se o de unidade passou. Não faz sentido gastar 10 minutos de navegador com uma regra básica quebrada.
  • Shards: A matriz cria três cópias do job, uma por fatia (shard) da suíte, rodando em máquinas diferentes ao mesmo tempo. fail-fast: false deixa as outras fatias terminarem mesmo se uma falhar, para você ver todas as falhas.
  • Rodar uma fatia: Cada cópia do job roda só a sua parte: 1/3, 2/3 ou 3/3. Uma suíte de 15 minutos passa a levar perto de 5.
  • Guardar mesmo se falhar: Sem essa linha, o passo seria pulado justamente quando os testes falham, que é quando você mais precisa do relatório.
  • Artefato: A pasta do relatório HTML, com traces e capturas de tela, fica disponível para download na página da execução por 14 dias.

Paralelizar só funciona com testes isolados. Dentro de uma máquina, o Playwright já usa vários workers; os shards dividem a suíte entre máquinas. Se um teste depende do que outro deixou no banco, ele vai falhar assim que os dois caírem em fatias ou workers diferentes.

Complete os passos finais do job de ponta a ponta para guardar o relatório mesmo quando um teste falha.

      - run: npx playwright test --shard=${{ matrix.shard }}
      - uses: actions/____@v4
        if: ${{ ____ }}
        with:
          name: relatorio-${{ strategy.job-index }}
          ____: playwright-report/

Testes instáveis e quarentena

O Playwright pode repetir um teste que falhou com a opção retries. Se ele passar na segunda tentativa, o relatório marca como flaky (instável), em vez de esconder. Isso deixa o pull request andar, mas é um aviso, não uma solução.

Trecho do playwright.config.ts comum em projetos que rodam na CI

export default defineConfig({
  retries: process.env.CI ? 2 : 0,
  workers: process.env.CI ? 2 : undefined,
  reporter: [['html'], ['junit', { outputFile: 'resultados/junit.xml' }]],
  use: {
    baseURL: 'http://localhost:5173',
    trace: 'on-first-retry',
  },
});

Com trace: 'on-first-retry', o Playwright grava o rastro justamente na tentativa extra, que é a evidência para investigar. O reporter junit gera um arquivo XML que muitas ferramentas de CI leem para mostrar quais testes falharam direto no pull request.

Quando um teste instável atrapalha a equipe e a correção vai demorar, ele vai para quarentena: continua rodando, mas fora do caminho que bloqueia o pull request, com uma issue aberta, uma pessoa responsável e um prazo. Quarentena sem dono vira cemitério de testes.

Uma etiqueta separa o teste em quarentena; a CI roda os dois grupos em passos diferentes.

// Issue #482: falha 3 em 20 execuções, suspeita de dados compartilhados (responsável: Bia)
test('aplica cupom de primeira compra', { tag: '@quarentena' }, async ({ page }) => {
  // ...
});

// No workflow:
//   npx playwright test --grep-invert @quarentena   -> bloqueia o pull request
//   npx playwright test --grep @quarentena          -> roda, mas não bloqueia

Coloque em ordem o tratamento de um teste instável.

  • Confirmar a instabilidade rodando o teste várias vezes com --repeat-each
  • Pôr em quarentena com uma issue, uma pessoa responsável e um prazo
  • Investigar a causa pelo trace da tentativa que falhou
  • Corrigir a causa: espera fixa, dados compartilhados, ordem ou data
  • Rodar de novo várias vezes e tirar o teste da quarentena

Alguém propõe: “vamos colocar retries: 5 e acabou o problema dos testes instáveis”. Qual o maior risco?

  • Bugs que aparecem só às vezes no produto, como uma condição de corrida, passam a ser escondidos pelas tentativas
  • Nenhum, porque se o teste passou em alguma tentativa, o código está certo
  • O GitHub Actions não permite mais de duas tentativas

Bug do produto ou falha do teste?

Quando a CI fica vermelha, a primeira pergunta não é “como faço passar?”, e sim “quem errou?”. Há três suspeitos: o produto mudou de comportamento, o teste está errado ou frágil, ou o ambiente (rede, serviço externo, máquina da CI) falhou. O relatório e o trace são as provas.

Pistas que ajudam a separar os três suspeitos
PistaAponta para
Falha sempre, desde um commit específico, e a tela no trace mostra o erro para a pessoaProduto
Passa e falha sem mudança no código; o relatório marca flakyTeste (ou condição de corrida no produto)
O texto ou a estrutura da tela mudaram de propósito e o teste não acompanhouTeste desatualizado
Vários testes sem relação falham juntos com timeout de rede ou erro ao instalarAmbiente

Leia cada falha da CI e decida o suspeito principal.

Bug do produto · Problema no teste · Ambiente

  • Desde ontem, todo pedido com cupom fica com total negativo no trace
  • O botão “Pagar” não aparece no celular em toda execução, desde o último merge
  • O teste procura “Comprar”, mas o time renomeou o botão para “Finalizar compra” de propósito
  • O teste falha só quando roda em paralelo com o de cadastro, que usa a mesma conta
  • Todos os jobs falharam no passo npm ci com erro de rede ao baixar pacotes
  • Os testes que usam a sandbox do provedor de pagamento falharam juntos por timeout, e a página de status dele mostra instabilidade
Na entrevista perguntam: “o que sua suíte não cobre?”. Por que responder isso com clareza conta pontos?

Porque nenhuma suíte cobre tudo, e quem sabe onde estão os buracos sabe onde está o risco. Uma boa resposta cita o que foi escolhido de propósito (por exemplo, sem testes de carga nem de outros navegadores além do Chromium) e por quê, mostrando que a estratégia foi pensada, não acumulada.

Fechamento

  • Pirâmide e troféu concordam: poucos testes de ponta a ponta nas jornadas críticas e a maior parte das conferências nos níveis rápidos.
  • Automatize primeiro o que tem risco alto e roda com frequência; deixe julgamento humano e descoberta para testes exploratórios.
  • Cobertura mostra o que nenhum teste executa, mas 100% não significa ausência de bugs: rodar uma linha não é conferir o resultado.
  • Na CI, separe jobs rápidos e lentos, divida a suíte em shards e guarde relatórios e traces como artefatos mesmo quando falha.
  • Testes instáveis vão para quarentena com dono e prazo; tentativas automáticas sinalizam o problema, mas não substituem corrigir a causa.

Faça a CI produzir um relatório e explicar uma falha

No repositório de testes que você está montando (com testes de API e de Playwright), coloque a suíte para rodar no GitHub Actions com relatório e mostre como você separa um bug do produto de uma falha do teste.

  1. Escreva em poucas linhas a estratégia: o que fica em unidade, em API e em ponta a ponta, e por quê
  2. Crie um workflow com um job rápido e um job de Playwright que dependa dele
  3. Guarde o relatório HTML como artefato com if: ${{ !cancelled() }} e abra-o depois de uma execução
  4. Quebre o produto de propósito, deixe a CI falhar e use o trace para explicar o defeito no pull request
  5. Faça um teste ficar instável (por exemplo, com uma espera fixa curta), confirme com --repeat-each e registre como você o corrigiria

Referências

Cursos relacionados