Desenvolvimento orientado a testes - me convença! [fechadas]

Sei que algumas pessoas são grandes defensoras do desenvolvimento orientado a testes. Eu usei testes de unidade no passado, mas apenas para testar operações que podem ser testadas facilmente ou que acredito que possivelmente estejam corretas. A cobertura completa ou quase completa do código parece demorar muito tempo.

1. Para quais projetos você usa o desenvolvimento orientado a testes? Você o usa apenas para projetos acima de um determinado tamanho?
2. Devo usá-lo ou não? Me convença!

Ok, algumas vantagens para o TDD:

1. Isso significa que você acaba com mais testes. Todo mundo gosta de fazer testes, mas poucas pessoas gostam de escrevê- los. A criação da gravação de testes no seu fluxo de desenvolvimento significa que você acaba com mais testes.
2. Escrever em um teste obriga a pensar na testabilidade do seu design, e o design testável é quase sempre um design melhor. Não está totalmente claro para mim por que isso acontece, mas minha experiência e a da maioria dos evangelistas de TDD parecem confirmar isso.
3. Aqui está um estudo dizendo que, embora o TDD demore um pouco mais para escrever, há um bom retorno sobre o investimento, porque você obtém um código de melhor qualidade e, portanto, menos bugs para corrigir.
4. Isso lhe dá confiança na refatoração. É uma ótima sensação poder alterar um sistema sem se preocupar em quebrar tudo o resto, porque é muito bem coberto por testes de unidade.
5. Você quase nunca recebe um bug repetido, pois todos os que encontrar devem fazer um teste antes de obter uma correção.

Você pediu para se convencer, então esses eram benefícios. Veja esta pergunta para uma visão mais equilibrada.

Robert C. Martin fez esses pontos originalmente - posso apoiá-los com minha própria experiência:

• Você criará automaticamente um conjunto de testes de regressão de testes de unidade à medida que avança.
• Você quase nunca gasta tempo depurando, como se você se codificasse em um buraco, é mais fácil desfazer seu código ao ponto em que o último teste passou, em vez de abrir um depurador.
• A cada poucos minutos, você verifica se seu código funciona - tudo (ou pelo menos todo o comportamento coberto pelos testes, que, se você estiver fazendo TDD, é uma porcentagem muito alta).

Pratico TDD o tempo todo, esteja trabalhando na produção ou no código do jogo; Atualmente, acho difícil codificar de qualquer outra maneira.

(Isenção de responsabilidade: quase não faço coisas com a interface do usuário, não posso discutir o TDD para UIs.)

Eu uso o TDD em praticamente tudo o que faço, de aplicativos triviais a pilhas SIP inteiras.

Não uso TDD em um site PHP herdado que assumi. Acho doloroso não fazer exames. E eu acho que é extremamente irritante quebrar acidentalmente partes do site porque eu não tenho um conjunto de testes de regressão dizendo que eu quebrei alguma coisa. O cliente não tem o orçamento para eu (a) escrever testes para a base de código e (b) no processo tornar o código testável em primeiro lugar, então eu apenas o aguento.

• Sempre que seu cliente puder ser fornecido com mais eficiência (eles possivelmente se relacionarão bem a testes - e isso pelo menos reduzirá a discussão no final do projeto)
• Sempre que levar mais tempo, mantenha seus co-desenvolvedores informados sobre TUDO no código do que se esforce na construção do teste - e isso é mais cedo do que você imagina

O que? Nenhuma resposta negativa !?

Isenção de responsabilidade: Eu não sou anti-unit-testing. Quando as pessoas dizem TDD, eu suponho que elas significam a versão que soa como doença em que estão escrevendo testes antes de escrever o código para 80-100% de todo o código que escrevem.

Eu deveria argumentar:

• É um facilitador. Se a captura de problemas de regressão é um problema tão grande para você que o TDD totalmente automático desde o início parece valer a pena, escrever testes para cada último pedaço de código que você escreve pode realmente ajudá-lo a ignorar o problema real.

• Ajuda as pessoas a ignorar o problema real. Ao consertar um bug, ele se transforma em um jogo de whack-a-mole, onde mais dois pop-ups, a arquitetura explode. Foco. Concentre-se no problema real. Ver as toupeiras antes que elas precisem ser golpeadas é legal, mas você não deveria estar lá em primeiro lugar.

• Come muito tempo. Eu batia erros ocasionais. Não encontro tantos que pareça valer a pena prefixar cada coisa nova que escrevo com um teste. Capture problemas onde eles provavelmente acontecerão. Manipule os erros de maneira que sejam fáceis de diagnosticar. Validar. Teste nos principais pontos de sobreposição / gargalo. Mas, pelo amor de Deus, não teste cada ultimo getter e setter em algo que provavelmente não deveria ter tido em primeiro lugar.

• Foco no design: não há absolutamente nenhuma maneira de um bom desenvolvedor escrever o melhor código possível quando também estiver focado no teste. Se parece que é a única maneira de ter um design decente, recomendo ver o item acima sobre "focar no problema real".

• Falha no design de macro: a base de código no meu trabalho atual está repleta de interfaces que nunca são usadas mais de uma vez e violações maciças do princípio DRY básico que só finalmente comecei a entender quando percebi que as pessoas estavam escrevendo para as estruturas de teste e testes em geral. O teste não deve levar a arquitetura estúpida. Não, na verdade, não há nada que seja de alguma forma mais escalável ou digno da empresa sobre copiar e colar 20 arquivos e, em seguida, fazer apenas alterações significativas em dois deles. A idéia é separar as preocupações, não dividi-las ao meio. Cruft e abstração sem sentido custarão mais do que não ter 95% de cobertura.

• É realmente popular e muitas pessoas realmente gostam. Se isso não for motivo suficiente para, pelo menos, adivinhar e / ou avaliar a porcaria de qualquer tecnologia antes da adoção, aprenda um pouco de paranóia.