🔍 Identificando gaps de cobertura
Antes de escrever testes, voce precisa saber o que testar. O Claude Code consegue analisar seu codigo-fonte, identificar funcoes sem cobertura, caminhos nao testados e logica critica exposta. Essa analise inicial e o que separa testes uteis de testes que apenas inflam metricas.
🎯 Conceito Principal
O Claude pode ler seu relatorio de coverage (lcov, istanbul, pytest-cov) e cruzar com o codigo-fonte para identificar exatamente quais funcoes, branches e linhas nao estao cobertas. Mais do que isso, ele prioriza pelo risco do que nao esta testado.
- • Analise de coverage: Peca ao Claude para ler o relatorio de cobertura e listar as funcoes com 0% de coverage, priorizando as mais criticas
- • Branches descobertos: Identifique if/else, try/catch e switch/case que so tem um caminho testado - esses sao os maiores pontos cegos
- • Priorizacao por risco: Funcoes que lidam com dinheiro, autenticacao, dados sensiveis ou integracao externa devem ser testadas primeiro
-
•
Prompt eficaz:
"Analise a cobertura de testes deste projeto. Identifique as 10 funcoes mais criticas sem testes."
💻 Exemplo no Terminal
💡 Dica Pratica
Nao busque 100% de cobertura cegamente. Peca ao Claude para focar nos 20% do codigo que representam 80% do risco: funcoes de pagamento, autenticacao, validacao de dados e logica de negocio central.
Uma boa abordagem e dizer: "Dado que temos 40% de coverage, quais funcoes devo testar para ter o maior impacto na confiabilidade do sistema?"
✍️ Gerando testes com Claude
Com os gaps identificados, e hora de gerar testes abrangentes. O Claude Code le o codigo-fonte da funcao, entende seu comportamento esperado, identifica edge cases e gera testes completos que seguem as convencoes do seu projeto.
🎯 Conceito Principal
O Claude gera testes que cobrem o caminho feliz, erros esperados e edge cases. Ele analisa a assinatura da funcao, os tipos de entrada/saida, as dependencias e o contexto de negocio para criar testes significativos.
- • Testes completos: O Claude gera testes para happy path, error cases, boundary values e null/undefined inputs automaticamente
- • Convencoes do projeto: Se voce ja tem testes existentes, o Claude imita o estilo (describe/it, test(), assert vs expect) e a estrutura de pastas
- • Mocks inteligentes: O Claude identifica dependencias externas (banco de dados, APIs, filesystem) e gera mocks apropriados
-
•
Prompt eficaz:
"Escreva testes para a funcao calculateDiscount em src/pricing.ts. Cubra happy path, erros e edge cases. Use o mesmo estilo dos testes existentes."
💻 Exemplo no Terminal
💡 Dica Pratica
Sempre peca ao Claude para ler os testes existentes antes de gerar novos. Isso garante consistencia de estilo. Use: "Leia os testes existentes em __tests__/ para entender o padrao, depois gere testes para X."
Para funcoes complexas, peca testes em etapas: primeiro o happy path, depois os erros, depois os edge cases. Isso da resultados mais detalhados do que pedir tudo de uma vez.
▶️ Verificando e rodando testes
Testes gerados por IA precisam ser validados e executados. O Claude Code pode rodar os testes, interpretar falhas, corrigir o codigo dos testes e re-executar ate que todos passem. Esse loop de feedback e uma das maiores vantagens do Claude sobre geradores de testes tradicionais.
🎯 Conceito Principal
O workflow de validacao e iterativo: gera → roda → falha → corrige → roda novamente. O Claude entende mensagens de erro, stack traces e diffs para ajustar os testes ate que estejam corretos. Isso e feito em um loop natural de conversa.
-
•
Executar testes: Peca ao Claude para rodar
npm testoupyteste analise os resultados automaticamente - • Interpretar falhas: O Claude le o output de erro e distingue entre testes mal escritos (corrige o teste) e bugs reais no codigo (reporta o bug)
- • Fix automatico: Quando o teste falha por setup incorreto (mock errado, import faltando), o Claude corrige e re-executa
- • Descoberta de bugs: Testes que falham podem revelar bugs reais no codigo de producao - o Claude distingue os dois cenarios
💻 Exemplo no Terminal
💡 Dica Pratica
Instrua o Claude a nao mais do que 3 tentativas de correcao por teste. Se um teste falhar 3 vezes, provavelmente ha um problema de design que precisa de intervencao humana.
Adicione ao CLAUDE.md: "Apos gerar testes, sempre rode-os. Se falharem, corrija e rode novamente. Maximo 3 tentativas por teste."
📈 Coverage check (medindo melhoria)
Apos gerar e validar os testes, e hora de medir o impacto real. O Claude pode rodar o coverage report antes e depois, calcular a melhoria e identificar o que ainda falta para atingir a meta de cobertura desejada.
🎯 Conceito Principal
Coverage check e o feedback quantitativo do seu esforco de testes. O Claude compara o antes e depois, mostra a evolucao por arquivo/funcao e sugere proximos passos para continuar melhorando a cobertura de forma estrategica.
- • Antes vs depois: Rode coverage antes de gerar testes e depois. O Claude calcula o delta e mostra quais areas melhoraram
- • Metricas importantes: Line coverage, branch coverage e function coverage. Branch coverage e a mais reveladora - mostra se todos os caminhos logicos estao testados
- • Gaps restantes: O Claude identifica o que ainda falta e estima quantos testes adicionais sao necessarios para atingir a meta
- • CI integration: Configure um threshold minimo no CI (ex: 80%) e o Claude ajuda a manter essa meta em cada PR
💻 Exemplo no Terminal
💡 Dica Pratica
Nao persiga 100% de cobertura - o retorno diminui drasticamente apos 80%. O esforco para ir de 80% a 90% e frequentemente maior do que de 40% a 80%. Foque em coverage de branches para logica critica.
Crie um script no package.json: "test:coverage": "jest --coverage --coverageThreshold='{\"global\":{\"branches\":80}}'" para enforcar o threshold automaticamente.
🔴🟢 TDD com Claude Code (test-first)
O Claude Code e um parceiro ideal para Test-Driven Development. Voce descreve o comportamento desejado, o Claude escreve o teste primeiro (que falha), depois implementa o codigo para fazer o teste passar. O ciclo Red-Green-Refactor ganha uma velocidade extraordinaria.
🎯 Conceito Principal
No TDD assistido por Claude, o ciclo e: descreva o comportamento → Claude escreve o teste → teste falha (RED) → Claude implementa o codigo → teste passa (GREEN) → Claude refatora (REFACTOR). Voce conduz a especificacao, o Claude executa.
- • RED - Escreva o teste: Descreva o comportamento em linguagem natural e peca ao Claude para escrever apenas o teste (sem implementacao)
- • GREEN - Implemente: Peca ao Claude para implementar o minimo de codigo necessario para o teste passar
- • REFACTOR - Melhore: Com o teste verde como rede de seguranca, peca ao Claude para refatorar o codigo mantendo os testes passando
- • Iteracao rapida: O Claude faz o ciclo completo em minutos, onde manualmente levaria horas. Voce foca na especificacao, ele na implementacao
💻 Exemplo no Terminal
💡 Dica Pratica
TDD com Claude funciona melhor quando voce descreve comportamentos em vez de implementacoes. Diga "deve retornar frete gratis para pedidos acima de R$200" em vez de "use um if para checar se o valor e maior que 200".
Adicione ao CLAUDE.md: "Quando eu disser 'TDD', escreva primeiro os testes, depois implemente o codigo para passar os testes, e finalmente refatore."
🧊 Testes de edge cases
Os bugs mais perigosos vivem nos edge cases: valores limite, entradas inesperadas, condicoes de corrida e estados impossiveis. O Claude Code e excelente em pensar nesses cenarios que humanos frequentemente esquecem, gerando testes que cobrem boundary values e error paths.
🎯 Conceito Principal
Edge cases sao os cenarios que ficam nas bordas do comportamento esperado. O Claude consegue analisar uma funcao e gerar sistematicamente testes para valores nulos, listas vazias, numeros negativos, strings gigantes, caracteres especiais, tipos errados e estados concorrentes.
- • Boundary values: Valores no limite exato (0, -1, MAX_INT, string vazia, array com 1 elemento) sao onde a maioria dos bugs se esconde
- • Error paths: O que acontece quando a API retorna 500? Quando o banco esta fora? Quando o disco esta cheio? Testes de resiliencia
- • Tipos inesperados: Em JavaScript/Python, o que acontece quando recebe undefined, NaN, Infinity ou um objeto onde esperava string?
- • Concorrencia: Duas chamadas simultaneas a mesma funcao, timeout durante operacao, cancelamento no meio de uma transacao
💻 Exemplo no Terminal
💡 Dica Pratica
Peca ao Claude para pensar como um "adversario" do codigo: "Tente quebrar esta funcao. Quais inputs causariam comportamento inesperado, crash ou dados corrompidos?" Isso gera testes muito mais reveladores do que pedir "escreva testes".
Uma abordagem poderosa: peca ao Claude para listar 20 edge cases possíveis, escolha os 10 mais relevantes, e entao peca para gerar testes so para esses.
🏋️ Exercicio Pratico
Aumentar coverage de 40% para 80% em um projeto real
Medir coverage inicial
Rode o coverage report e anote o percentual atual:
Anote: Lines __%, Branches __%, Functions __%
Identificar gaps com Claude
Peca ao Claude para analisar e priorizar:
Gerar testes para as funcoes priorizadas
Para cada funcao identificada, peca testes completos:
Rodar, corrigir e validar
Peca ao Claude para executar e corrigir ate todos passarem:
Medir coverage final e comparar
Rode coverage novamente e compare:
Meta: coverage acima de 80% em lines e branches.
✅ Criterios de Sucesso
📋 Resumo do Modulo
Proximo Modulo:
3.6 - Workflow: Code Review e Pull Request