Ganhos:
- Capacidade de produzir testes de unidade, integração e casos extremos com afirmação significativa com IA
- Capacidade de extrair sistematicamente cobertura de testes, valores limite e cenários negativos com suporte de IA
- Capacidade de verificar se os testes produzidos pela IA realmente verificam o comportamento e não apenas repetem o código existente
O teste é o mecanismo que prova que o software realmente se comporta conforme prometido. Um bom conjunto de testes informa em segundos se uma alteração prejudica alguma coisa e dá ao engenheiro a liberdade de agir com confiança. A IA acelera a parte mais tediosa e ignorada da escrita de testes: gerar uma infinidade de cenários, pontos de interrupção e casos negativos. Mas há aqui uma armadilha sorrateira: a IA pode escrever testes que verificam o comportamento atual (talvez defeituoso) do código, e não o seu suposto comportamento; ou pode produzir testes vazios que sempre passam, sem realmente verificar nada. O valor de um teste não está em ser aprovado, mas em verificar se está certo e ficar vermelho quando está errado.
Nesta unidade, você aprenderá como produzir testes de unidade, integração e casos extremos com asserções significativas; como extrair sistematicamente cobertura de testes, pontos de interrupção e cenários negativos; e veremos como você pode verificar se os testes que a IA produz realmente validam o comportamento.
Conceitos: Teste unitário: testa uma única função/classe isoladamente. Teste de integração: testa se várias partes funcionam juntas corretamente. Assert: Uma declaração que verifica se o resultado é igual ao esperado; Este é o cerne do teste. Cobertura: quanto do código é executado por testes; Alta cobertura não garante qualidade.
Produzindo testes significativos
Um bom teste faz claramente três coisas: estabelece um estado, executa uma ação e afirma o resultado. Ao imprimir testes para a IA, especifique qual comportamento você deseja verificar e quais cenários ele deve abranger; Caso contrário, produz testes superficiais que sempre passam.
- Defina o comportamento a ser testado. “O que é considerado certo?” Responda a pergunta com clareza.
- Peça tipos de cenário. Normal, limite, negativo, condição de erro.
- Importe afirmação significativa. Ele não apenas "lançou um erro", mas "retornou o valor correto".
- Verifique a precisão do teste. O teste fica vermelho quando você quebra o código conscientemente?
Prompt de geração de teste abrangente: "Escreva testes de unidade para a seguinte função 'applydiscount (valor, cupom)'. Tenha PELO MENOS um cenário nas seguintes categorias: (1) cupom válido normal, (2) pontos de interrupção (valor 0, desconto de 100%), (3) negativo (cupom inválido, valor negativo), (4) caso de erro (cupom nulo). Afirme o valor esperado CONCRETO em cada teste (não apenas 'funcionou'). Nomeie os testes legíveis. Código: [código]"
Prompt de extração de valor limite: "Realize uma análise de valor limite para as entradas desta função. Para cada parâmetro, extraia os valores 'logo no limite', 'logo abaixo do limite', 'logo acima do limite' como uma tabela. Em seguida, liste os cenários de teste que cobrem esses limites. Não escreva código ainda, apenas análise e lista de cenários. Função: [assinatura]"
Cuidado: A alta cobertura de testes (por exemplo, 90%) não prova que o código esteja correto. A cobertura mede quantas linhas foram executadas; não que essas linhas produzam o resultado correto. Um teste sem afirmação significativa aumenta a cobertura, mas não garante nada. O conteúdo da afirmação determina a qualidade, não o número de afirmações.
Testando o próprio teste: a lógica da mutação
A maneira mais prática de entender se o teste gerado pela IA realmente funciona é quebrar deliberadamente o código (lógica de teste de mutação). Inverta uma condição, faça um sinal + -; Se nenhum teste ficar vermelho, seus testes não estão mantendo esse comportamento.
Prompt de busca de vulnerabilidade de teste: "Diga-me quais bugs potenciais neste código os testes a seguir NÃO PODEM detectar. Sugira 5 pequenas mutações que podem ser feitas no código (por exemplo, >= em vez de >, - em vez de +) e indique para cada uma se os testes existentes o detectariam. Para aqueles que não foram detectados, sugira testes que devem ser adicionados. Código: [código] Testes: [teste]"
Alerta Fraco/Prompt Forte
FRACO: "Escreva um teste para esta função." (Resultado: geralmente um cenário feliz, afirmação fraca; perde erros.) FORTE: "Escreva um teste para esta função 'passwordStrong'. Regra: pelo menos 8 caracteres, 1 letra maiúscula, 1 dígito obrigatório. Cubra os seguintes cenários como testes SEPARADOS: exatamente 8 caracteres (limite), 7 caracteres (abaixo do limite), sem letras maiúsculas, sem dígitos, string vazia, apenas espaços, muito longos (1000 caracteres) Afirme explicitamente o valor verdadeiro/falso esperado em cada test e nomeie o teste de acordo com o que ele verifica."
Prompt poderoso fornece regras e cenários de limites completos. Pares de limites como "exatamente 8/7 caracteres" são os locais mais comuns para cometer erros (confundir > com >=). O prompt fraco ultrapassa esses limites e leva o erro para a produção.
Tipos de teste e onde usar
Tipo de teste
O que isso confirma?
Contribuição de IA
Atenção
unidade
Função/classe única
Gera vários cenários rapidamente
Afirmação significativa é necessária
integração
Peças trabalhando juntas
Cenário e rascunho de dados simulados
Comportamento viciante verdadeiro
terminar/aceitar
Todo o fluxo do usuário
Lista de etapas e expectativa
propenso a fragilidade
regressão
Erro antigo não retornando
Teste específico de falha
Deve ser adicionado a cada correção
Mini-casos
Caso 1 — O teste que sempre passa. A IA escreve 12 testes em uma função e todos passam. O engenheiro fica desconfiado e distorce deliberadamente o valor de retorno da função; Apenas 3 dos testes ficam vermelhos. Os outros 9 testes não contêm afirmações significativas. Os testes são fortalecidos pela caça às mutações; a proteção real é obtida em 9 cenários.
Caso 2 — Erro de limite. Uma função de verificação de idade deveria dizer "18 anos ou mais é válido", mas >18 está escrito, o que significa que 18 anos é rejeitado. O erro aparece imediatamente nos testes porque a IA gera o cenário “exatamente 18” por meio da análise de breakpoint. Um único teste de limite evita reclamações reais de usuários.
Caso 3 — Corrigindo o comportamento atual. Quando a IA é instruída a “escrever um teste baseado neste código”, ela produz um teste que aceita como “correto” um erro de arredondamento que já existe no código. Quando o engenheiro imprime o teste de acordo com o requisito (valor correto esperado) e não o código, o teste fica vermelho e ocorre o erro real. Os testes devem ser derivados de expectativas, não de código.
Erros comuns
- Afirmação inútil. "Não ocorreu um erro" não é suficiente; O valor correto deve ser verificado.
- Confundindo escopo com qualidade. Alta cobertura não é garantia de resultados precisos.
- Imprimindo o teste por código. Corrige o erro atual para “true”; Os testes devem derivar da expectativa.
- Ignorando valores limite. Confundir > com >= é o erro mais comum; pares de limites devem ser testados.
- Não auditar o teste em si. Um teste que não fica vermelho quando você quebra o código não oferece proteção.
Em resumo
Um bom conjunto de testes é a chave para fazer alterações com confiança. A IA gera rapidamente uma infinidade de cenários, limites e situações negativas; Mas se derivar testes do código em vez de requisitos, poderá corrigir bugs existentes ou escrever testes sem sentido que sempre passam. Afirme o valor concreto esperado em cada teste, inclua pares vinculados e verifique se seus testes realmente protegem quebrando deliberadamente o código. O conteúdo da afirmação, e não o número de escopos, determina a qualidade.
Tarefa de aplicativo
Selecione uma função e faça com que ela gere testes em quatro categorias (normal, limite, negativo, erro) com um prompt abrangente de geração de teste; Tenha o valor esperado concreto afirmado em cada teste. Em seguida, execute o prompt de teste de busca de vulnerabilidade, sugira 5 pequenas mutações no código e execute os testes para verificar quais elas foram detectadas. Adicione um novo teste para pelo menos uma mutação que não foi detectada e mostre que agora está no vermelho.
lista de verificação
- [] Imprimi os testes com base no comportamento esperado/correto, não no código.
- [] Abordei cenários normais, limite, negativos e de erro.
- [] Afirmei o valor concreto esperado em cada teste.
- [] Testei pares de bordas (logo acima-abaixo/logo acima-abaixo).
- [] Ao quebrar deliberadamente o código, confirmei que os testes ficaram vermelhos.
- [] Adicionei um novo teste para mutações não detectadas.