Em sistemas críticos — financeiros, de saúde, de infraestrutura — um bug em produção não é um inconveniente, é um incidente com custo real: financeiro, regulatório ou reputacional. E a resposta instintiva a esse risco costuma ser errada: escrever mais testes, de qualquer tipo, em qualquer proporção. O resultado, na prática, é uma suíte de testes lenta, frágil e que ninguém confia o suficiente para bloquear um deploy.

Uma estratégia de testes eficaz não maximiza a quantidade de testes — maximiza a confiança por segundo de execução. Isso exige uma pirâmide bem balanceada.

A pirâmide de testes, na prática

  • Testes unitários (a base, ~70%) — validam uma unidade de lógica isolada, sem dependências externas. Rápidos (milissegundos), baratos de escrever e os primeiros a rodar em cada commit.
  • Testes de integração (~20%) — validam que múltiplos componentes reais — banco de dados, filas, APIs internas — funcionam corretamente juntos. Mais lentos, mais caros, mas cobrem o que os unitários não alcançam.
  • Testes E2E (o topo, ~10%) — simulam o caminho completo do usuário através da interface real. Os mais caros, mais lentos e mais frágeis a mudanças de UI — por isso devem cobrir só os fluxos de negócio mais críticos.
O anti-padrão do cone invertido
Times que investem pesado em testes E2E e pouco em unitários acabam com suítes que levam horas para rodar, quebram por motivos que nada têm a ver com o bug real, e são frequentemente desligadas sob pressão de prazo — o pior resultado possível.

O que priorizar em sistemas críticos

Cobertura de código em porcentagem é uma métrica enganosa: 100% de cobertura não significa ausência de bugs, só significa que cada linha foi executada ao menos uma vez. Para aplicações críticas, priorize por risco de negócio, não por linha de código:

  1. Fluxos que envolvem dinheiro ou dados sensíveis — cobertura próxima de 100%, com testes de casos extremos e cenários de falha, não só do caminho feliz.
  2. Regras de negócio complexas — cálculos, validações e máquinas de estado merecem testes unitários exaustivos, porque são onde bugs sutis se escondem.
  3. Integrações com terceiros — testes de contrato (contract testing) garantem que mudanças em uma API externa sejam detectadas antes de quebrar produção.
  4. Caminhos de recuperação de falha — o que acontece quando o banco de dados cai no meio de uma transação? Sistemas críticos precisam testar isso deliberadamente, não descobrir na hora.
A pergunta que orienta onde testar mais não é "isso é fácil de testar?" — é "quanto custa para o negócio se isso quebrar em produção?"
Newsletter

Engenharia que vai direto ao ponto.

Conteúdo técnico para engenheiros e decisores. Sem enrolação, sem spam — só o que importa.

Sem spam. Cancele quando quiser.

Testes como parte do CI, não como etapa manual

Uma estratégia de testes só entrega valor real quando é automática e obrigatória: toda mudança de código roda a suíte completa de testes unitários e de integração antes de poder ser mesclada, e testes E2E críticos rodam antes de qualquer deploy em produção. Testes que dependem de alguém lembrar de rodar manualmente eventualmente param de rodar.

Igualmente importante: testes instáveis (flaky tests) que falham aleatoriamente sem relação com o código devem ser tratados como incidentes, não ignorados. Um time que aprende a ignorar falhas de teste eventualmente vai ignorar a falha real que importava.

No Kordis Lab, estruturamos a estratégia de testes junto com a arquitetura, não depois — para sistemas críticos, isso significa desenhar código testável desde o início e ter cobertura de regras de negócio antes de qualquer deploy em produção, integrada de forma nativa ao pipeline de CI/CD do time.

Compartilhar