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 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:
- 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.
- 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.
- Integrações com terceiros — testes de contrato (contract testing) garantem que mudanças em uma API externa sejam detectadas antes de quebrar produção.
- 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?"
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.