Se eu já tenho um teste de integração para o meu programa e todos foram aprovados, sinto que ele funcionará. Quais são os motivos para escrever / adicionar testes de unidade? Como já tenho que escrever testes de integração, gostaria de escrever apenas testes de unidade para peças que não são cobertas por testes de integração.
O que eu sei os benefícios do teste de unidade sobre o teste de integração são
- Pequeno e, portanto, rápido de executar (mas adicionar uma nova unidade para testar algo já foi testado pelo teste de integração significa que meu traje de teste total fica maior e mais longo para executar)
- Localize o bug com mais facilidade porque ele só testa uma coisa (mas posso iniciar o teste de unidade de gravação para verificar cada parte individual quando meu teste de integração falhou)
- Encontre um bug que pode não ser detectado no teste de integração. por exemplo, mascaramento / correção de erros. (mas se minha integração testar todas as aprovações, o que significa que meu programa funcionará mesmo que exista algum bug oculto. Portanto, encontre / corrija esses bugs não são realmente de alta prioridade, a menos que comecem a interromper futuros testes de integração ou causem problemas de desempenho)
E sempre queremos escrever menos código, mas os testes de unidade de gravação precisam de muito mais código (principalmente a configuração de objetos simulados). A diferença entre alguns dos meus testes de unidade e testes de integração é que, nos testes de unidade, eu uso objetos simulados, e nos testes de integração, eu uso objetos reais. Que têm muita duplicação e eu não gosto de código duplicado, mesmo em testes, porque isso adiciona uma sobrecarga para alterar o comportamento do código (a ferramenta refatorar não pode fazer todo o trabalho o tempo todo).
fonte
Respostas:
Você apresentou bons argumentos a favor e contra o teste de unidade. Então você deve se perguntar: " Vejo valor nos argumentos positivos que superam os custos nos negativos? " Certamente:
No meu livro, os profissionais superam os contras.
fonte
Não vejo muito valor em reimplementar uma integração-testcase existente como unittest.
Os testes de integração costumam ser muito mais fáceis de escrever para aplicativos herdados não tdd, porque geralmente as funcionalidades a serem testadas são fortemente acopladas, de modo que as unidades de teste isoladas (= sem teste) podem ser difíceis / caras / impossíveis.
Na minha opinião, o desenvolvimento orientado a testes é mais eficaz se você escrever os testes de unidade antes do código real. Dessa forma, o código que realiza os testes se torna claramente separado com um mínimo de referências externas fáceis de serem testadas.
Se o código já existir sem os testes de unidade, geralmente é muito trabalhoso escrever os testes de unidade posteriormente, porque o código não foi escrito para facilitar o teste.
Se você fizer TDD, o código será automaticamente testado facilmente.
fonte
unit-tests
, e quero incluirunit-tests
em algumas partes, você acha melhor escrever primeirointegration tests
o código legado. Uma vez escrito, você pode desacoplar o acoplamento rígido e criar funções com interfaces que podem ser testadas? Desde que você jáintegration-test
tenha escrito, poderá verificar em cada etapa da refatoração, se a nova versão do código ainda funciona como desejado?Os testes de integração devem apenas verificar se vários componentes estão funcionando juntos conforme o esperado. A precisão ou não da lógica dos componentes individuais deve ser verificada por testes de unidade.
A maioria dos métodos possui vários caminhos de execução possíveis; pense nas variáveis de entrada if-then-else, com valores inesperados ou simplesmente errados etc. Geralmente, os desenvolvedores tendem a pensar apenas no caminho feliz: o caminho normal que não dá errado. Mas, no que diz respeito a esses outros caminhos, você tem duas opções: você pode permitir que o usuário final explore esses caminhos por meio das ações que eles executam na interface do usuário e espero que não travem seu aplicativo, ou você pode escrever testes de unidade que afirmam o comportamento desses outros caminhos e tome as medidas necessárias.
fonte
Algumas das razões pelas quais você apontou na sua pergunta são realmente importantes e, por si só, poderiam muito bem defender o teste de unidade, mas o YMMV. Por exemplo, com que frequência você executa seu conjunto de testes integrado? Minha experiência com testes integrados é que mais cedo ou mais tarde eles ficarão tão lentos que você não os executará toda vez que fizer uma alteração e o tempo entre a inserção e a detecção de um bug aumentará.
Além disso, um grande erro que você pode estar cometendo é confiar que
Find bug that may not be caught in integration test. e.g. masking/offsetting bugs.
não é importante. Você espera que seus usuários encontrem os bugs para você? Confiar em coberturas obtidas a partir de testes integrados é perigoso, na minha opinião, você pode obter muito facilmente uma alta% de cobertura, mas, na realidade, está testando muito pouco.
Eu acho que a referência canônica contra testes integrados são os posts do JBrains:
http://www.jbrains.ca/permalink/integrated-tests-are-a-scam-part-1
caso você ainda não os tenha lido.
Por fim, na IMO, o feedback que você pode obter dos testes de unidade para seu projeto é inestimável. Julgar um projeto pelo instinto e confiar em testes integrados também pode ser um erro.
fonte
Se você espera ter que modificar ou refatorar seu código, é essencial ter testes de unidade. Os testes de unidade existem não apenas para demonstrar erros no momento em que o código é gravado, mas para mostrar quando novos erros aparecem quando mais código é gravado.
Sim, é muito melhor escrever seus testes de integração e unidade primeiro, mas há muito valor em tê-los, mesmo que sejam escritos posteriormente.
fonte