Testes de unidade, de integração e de ponta a ponta: onde a IA mais ajuda
By Mirko Peters · · Updated
Testes de unidade, de integração e de ponta a ponta: o que cada um verifica, quantos escrever e onde a IA mais ajuda, desde o rascunho de testes unitários até a revisão de fluxos no navegador.
Automatically translated with AI from the original post. Read the English original
Testes de unidade, de integração e de ponta a ponta são a questão por trás de qualquer estratégia de testes de software: cada nível verifica algo diferente, custa um valor diferente e oferece um tipo diferente de confiança. Este guia é para líderes de QA que precisam definir onde a IA deve entrar nos testes de software. Você verá o que cada nível verifica, quantos testes de cada tipo uma suíte saudável contém, onde a IA mais ajuda e onde ela aumenta o risco. Um exemplo prático, com números fictícios, mostra como uma equipe decidiu onde concentrar seu esforço.
Pontos-chave
- Um teste de unidade verifica um trecho de código, um teste de integração verifica a conexão com algo externo à aplicação, e um teste de ponta a ponta exercita o sistema implantado por meio de sua interface.
- A pirâmide de testes recomenda escrever muitos testes de unidade pequenos e rápidos, alguns testes mais abrangentes e pouquíssimos testes de alto nível, porque os níveis mais altos são mais lentos e exigem mais manutenção.
- A IA é mais útil onde o resultado é pequeno e fácil de verificar, como no rascunho de testes de unidade e de API, e onde uma pessoa consegue revisar cada teste gerado.
- Testes gerados por IA podem inflar a cobertura sem validar o comportamento, por exemplo testes que executam o código, mas têm asserções fracas ou inexistentes.
- Trate o resultado da IA como rascunho em todos os níveis e reserve o julgamento humano para fluxos ambíguos, verificações visuais e revisões de acessibilidade.
Testes de unidade, de integração e de ponta a ponta: o que cada um verifica
O artigo The Practical Test Pyramid, de Martin Fowler, traz definições claras.
- Testes de unidade garantem que uma determinada unidade da sua base de código, o sujeito do teste, funcione conforme o esperado. Eles têm o escopo mais restrito de todos os tipos de teste. Este é o nível de testes de unidade que os desenvolvedores escrevem com mais frequência.
- Testes de integração verificam a integração da sua aplicação com as partes que ficam fora dela, como um banco de dados, um sistema de arquivos ou um serviço separado. Fowler prefere testes restritos, que avaliam um ponto de integração externo por vez. Esse é o papel dos testes de integração.
- Testes de ponta a ponta testam a aplicação implantada por meio da sua interface de usuário e cobrem o sistema integrado como um todo. Fowler os chama de testes de pilha ampla. Esse é o teste de ponta a ponta.
A principal diferença entre o teste de unidade e o teste de integração é o escopo: uma parte do código contra a conexão entre as partes. Testes funcionais e testes de sistema também verificam o software a partir de fora, e o teste de ponta a ponta é a forma conduzida pelo navegador, então alinhe bem os termos usados pela equipe.
Os desenvolvedores normalmente escrevem testes de unidade e os executam a cada commit. Para lembrar a diferença, pense na pergunta que cada nível responde: um teste de unidade pergunta se esta função está correta. Um teste de integração pergunta se conversamos corretamente com este outro sistema. Um teste de ponta a ponta pergunta se um usuário consegue concluir esta jornada.
Quantos de cada tipo: a pirâmide de testes
A pirâmide de testes é a forma usual de descrever esse equilíbrio. O conselho de Fowler é escrever muitos testes unitários pequenos e rápidos, alguns testes de granularidade mais grossa e pouquíssimos testes de alto nível. Ele coloca isso como regra: quanto mais alto o nível, menos testes você deve ter.
O motivo é o custo. De acordo com o artigo, testes unitários são executados muito rapidamente, testes de integração tendem a ser bem mais lentos porque envolvem partes externas reais, e testes de ponta a ponta rodam de forma bastante lenta. Além disso, os testes de ponta a ponta exigem muita manutenção e são notoriamente instáveis.
Essa instabilidade é mensurável em escala. Um post do Google Testing Blog, Flaky Tests at Google and How We Mitigate Them, relata que cerca de 1,5 por cento das execuções de teste tiveram resultado instável e quase 16 por cento dos testes apresentaram alguma instabilidade.
Os três níveis alimentam a regressão, porque são executados novamente após cada mudança.
Fowler também alerta contra o formato oposto, que ele chama de cone de sorvete de testes: muitos testes manuais e em nível de navegador no topo, poucos testes unitários na base. Ele descreve isso como um pesadelo de manutenção que leva tempo demais para rodar. Se a sua suíte se parece com isso, adicionar IA não vai corrigir o formato. Pode apenas gerar mais testes lentos, e mais rapidamente.
Teste unitário vs. teste de integração: quando usar cada nível
A comparação da TestRail sobre testes unitários e de integração lista diferenças práticas. Testes unitários são rápidos de implementar e de executar, e normalmente são feitos por desenvolvedores. Testes de integração costumam envolver engenheiros de QA e testadores. Testes unitários usam mocks e stubs para evitar sistemas externos, enquanto o teste de integração foca em interações reais, mas ainda pode usar mocks quando um serviço externo está indisponível, não é confiável ou é caro.
As vantagens do teste unitário são feedback rápido, detecção precoce de bugs e código mais modular. Sua fraqueza é que uma suíte de testes unitários não mostra se as partes funcionam juntas, e é isso que o teste de integração acrescenta. A TestRail sugere testes unitários para lógica isolada no início do desenvolvimento, e testes de integração para fluxos que atravessam módulos, bancos de dados ou serviços de terceiros. Ela descreve duas formas de executar estes últimos: Big Bang, que testa tudo junto após o desenvolvimento e é mais difícil de depurar, e incremental, que testa pequenos grupos passo a passo e facilita a localização dos problemas.
Fowler dá uma regra para decidir o nível: se um teste de nível mais alto encontra um erro e nenhum teste de nível mais baixo falha, escreva um teste de nível mais baixo. Empurre os testes o mais para baixo na pirâmide que puder e remova os testes de alto nível que duplicam o que os níveis inferiores já cobrem. Uma estratégia de testes abrangente usa os três níveis, com cada nível superior focado no que os inferiores não conseguem cobrir.
Duas perguntas relacionadas aparecem com frequência. Fowler observa que alguns chamam a camada do meio de testes de integração e outros de testes de componente, e que concordar com os termos importa mais do que o nome. Ele também diz que os testes de aceitação, que verificam o software na perspectiva do usuário, podem estar em qualquer nível, por isso são ortogonais à pirâmide. Testes unitários e testes de ponta a ponta são, portanto, as duas extremidades de uma mesma escala, e não escolas rivais.
Esses testes são fáceis de automatizar em um pipeline. A TestRail diz que os testes unitários normalmente rodam cedo, muitas vezes logo após um push ou pull request, e que os testes de integração rodam depois, quando a aplicação já foi implantada em um ambiente de staging ou de testes. Juntos, eles formam um portão de qualidade.
Onde a IA mais ajuda
As ferramentas baseadas em IA generativa são diferentes entre si, mas um padrão aparece nas orientações dos fornecedores. O artigo da Parasoft sobre como a IA é usada em testes de software aconselha as equipes a gerar testes unitários e de API enquanto as mudanças ainda estão frescas, e menciona a ajuda da IA na criação de testes de API, na sugestão de asserções e na montagem de cenários de dados. Ele também observa que a virtualização de serviços, que simula dependências lentas, caras ou indisponíveis, apoia o teste de integração.
Isso combina com a pirâmide. Os motivos são inferência nossa, não uma medição:
- Saída pequena é fácil de revisar. Um teste unitário gerado tem poucas linhas. Quem revisa consegue ler, executar e decidir em um minuto se ele verifica a coisa certa.
- Feedback rápido expõe testes ruins. Um teste unitário errado falha ou passa rapidamente, então você encontra o problema no mesmo dia.
- Entradas e saídas claras. Funções e chamadas de API têm entradas e saídas definidas, então uma ferramenta tem um alvo preciso.
- Muitos casos repetitivos. Valores de limite e caminhos de erro são repetitivos em testes unitários, e um rascunho economiza digitação.
Deixe a IA criar o rascunho, mas quem assume a responsabilidade é uma pessoa: quem aceita um teste gerado responde pelo que ele verifica, exatamente como faria com um teste escrito à mão.
Para testes de integração, a IA pode criar um caso de teste ou dados de teste e simular dependências, mas uma pessoa precisa decidir qual é o contrato com o outro sistema, e o teste de integração verifica esse contrato.
No nível de testes de ponta a ponta, a IA ajuda de outra forma. Ferramentas que executam passos descritos em linguagem natural em um navegador podem reduzir o custo de escrever um teste de jornada. Elas não mudam o custo de executá-lo e não eliminam a necessidade de uma regra clara de aprovação ou reprovação.
Onde a IA ajuda menos, e o que observar
O artigo da Parasoft é direto sobre os limites. Ele recomenda manter revisão humana em cada alteração gerada por IA e tratar a saída da IA como rascunho. Diz que, usada de forma inadequada, a IA pode inflar a cobertura sem validar o comportamento, e alerta sobre testes vazios que executam caminhos de código, mas têm asserções fracas ou ausentes. Ele aponta como sinal de alerta saídas que variam entre execuções com as mesmas entradas. Acrescenta que a IA não pode aprovar alterações críticas para a segurança nem substituir o julgamento humano em fluxos ambíguos, verificações visuais e revisões de acessibilidade. Em relação aos dados, alerta contra prompts que contenham segredos ou dados regulamentados.
Estratégias de teste que usam IA precisam de quatro verificações:
- Cobertura que sobe, mas não detecta nada. Verifique as asserções, não apenas os números de cobertura.
- Testes que espelham o código. Um teste que repete a implementação passará mesmo quando a lógica estiver errada.
- Saída instável. Se um teste gerado muda entre execuções, fixe a versão que você revisou.
- Dados saindo da organização. Não cole segredos, dados de clientes ou dados regulamentados em um prompt.
Exemplo: onde uma equipe concentra seu esforço
Os números são fictícios.
Uma equipe tem 600 testes automatizados: 450 testes unitários, 110 testes de integração e 40 testes de ponta a ponta. Os testes de navegador levam 50 minutos de um pipeline de 60 minutos, e seis deles falham aleatoriamente a cada semana.
O líder de QA toma três medidas. Primeiro, um assistente de IA cria rascunhos de testes unitários para o código novo, e um desenvolvedor revisa cada rascunho. No primeiro mês, o assistente cria 120 testes. Os revisores rejeitam 30 deles porque as asserções são fracas, então 90 entram na suíte.
Segundo, a IA cria dados de teste para os testes de integração, e os contratos continuam escritos à mão.
Terceiro, os 40 testes de ponta a ponta não recebem ajuda da IA. O líder remove seis duplicatas que um teste de nível inferior, mais rápido, já cobre, e o pipeline cai de 60 para 48 minutos. O esforço com IA foi para onde a revisão é mais barata, e a camada lenta ficou menor.
Erros comuns
- Usar IA para criar mais testes de navegador. A camada lenta e instável cresce, e o pipeline fica mais lento.
- Aceitar testes gerados sem ler. Asserções fracas dão cobertura sem segurança.
- Medir o sucesso pela quantidade de testes. Conte, em vez disso, os defeitos detectados e os minutos economizados.
- Pular os testes de integração. Testes unitários somados a algumas jornadas podem deixar passar contratos quebrados entre sistemas.
- Colar dados sensíveis em prompts. Defina uma política antes do primeiro prompt.
Como o software pode ajudar
Seu framework de testes atual e seu sistema de CI já registram tempos de execução e taxas de falha. Comece por aí e agrupe os números por nível. Ferramentas de revisão de código ajudam com os rascunhos da IA, porque os revisores veem o teste gerado ao lado do código. Use ferramentas de cobertura sempre junto com uma verificação de asserções, para que cobertura não seja confundida com qualidade. Adicione um assistente de IA a um nível de teste primeiro e compare o tempo de revisão, os rascunhos rejeitados e os defeitos que escaparam antes de ampliar o piloto.
Próximo passo
Conte seus testes em cada nível, e anote o tempo de execução e a taxa de instabilidade de cada nível. Depois escolha um nível para o piloto de IA e registre o que você vai medir, para que sua próxima discussão sobre testes unitários versus integração versus ponta a ponta comece com dados.