O teste de unidade vale o esforço? [fechadas]

Estou trabalhando para integrar o teste de unidade no processo de desenvolvimento na equipe em que trabalho e há alguns céticos. Quais são algumas boas maneiras de convencer os desenvolvedores céticos da equipe sobre o valor dos testes de unidade? No meu caso específico, estaríamos adicionando testes de unidade à medida que adicionamos funcionalidade ou bugs corrigidos. Infelizmente, nossa base de código não se presta a testes fáceis.

Todos os dias em nosso escritório, há uma troca que é mais ou menos assim:

"Cara, eu simplesmente amo testes de unidade, apenas consegui fazer várias alterações na maneira como as coisas funcionam e, em seguida, consegui confirmar que não havia quebrado nada executando o teste novamente ..."

Os detalhes mudam diariamente, mas o sentimento não. Os testes de unidade e o desenvolvimento orientado a testes (TDD) têm tantos benefícios ocultos e pessoais quanto os óbvios que você simplesmente não consegue explicar para alguém até que eles mesmos o façam.

Mas, ignorando isso, aqui está a minha tentativa!

1. Testes de unidade permitem fazer grandes alterações no código rapidamente. Você sabe que funciona agora porque você executou os testes; quando você faz as alterações necessárias, é necessário que os testes funcionem novamente. Isso economiza horas.

2. O TDD ajuda você a perceber quando parar a codificação. Seus testes dão a você a confiança de que você já fez o suficiente por enquanto e pode parar de ajustar e passar para a próxima coisa.

3. Os testes e o código trabalham juntos para obter um código melhor. Seu código pode estar com defeito / com erros. Seu teste pode estar com defeito / com erros. No TDD, você está apostando nas chances de ambos serem ruins / com bugs baixos. Muitas vezes, é o teste que precisa ser corrigido, mas esse ainda é um bom resultado.

4. O TDD ajuda na codificação da constipação. Quando se depara com um trabalho grande e assustador adiante, escrever os testes fará com que você se mova rapidamente.

5. Os testes de unidade ajudam a entender realmente o design do código em que você está trabalhando. Em vez de escrever código para fazer algo, você está começando descrevendo todas as condições às quais está submetendo o código e quais resultados você esperaria disso.

6. Os testes de unidade oferecem feedback visual instantâneo, todos gostamos da sensação de todas essas luzes verdes quando terminamos. É muito gratificante. Também é muito mais fácil entender de onde você parou após uma interrupção, porque você pode ver para onde chegou - a próxima luz vermelha que precisa ser corrigida.

7. Ao contrário do teste de unidade de crença popular, não significa escrever duas vezes mais código ou codificar mais lentamente. É mais rápido e mais robusto do que a codificação sem testes, depois que você pega o jeito. O código de teste em si geralmente é relativamente trivial e não adiciona uma grande sobrecarga ao que você está fazendo. Este é o que você só vai acreditar quando estiver fazendo isso :)

8. Eu acho que foi Fowler quem disse: "Testes imperfeitos, executados com frequência, são muito melhores que testes perfeitos que nunca são escritos". Eu interpreto isso como me dando permissão para escrever testes nos quais acho que serão mais úteis, mesmo que o restante da minha cobertura de código seja lamentavelmente incompleta.

9. Bons testes de unidade podem ajudar a documentar e definir o que algo deve fazer

10. Os testes de unidade ajudam na reutilização do código. Migre seu código e seus testes para seu novo projeto. Ajuste o código até que os testes sejam executados novamente.

Um monte de trabalho com o qual estou envolvido não funciona bem no teste de unidade (interações com usuários de aplicativos da Web etc.), mas mesmo assim todos nós estamos infectados com testes nesta loja e mais felizes quando temos nossos testes vinculados. Não posso recomendar a abordagem o suficiente.

O teste de unidade é muito parecido com ir à academia. Você sabe que é bom para você, todos os argumentos fazem sentido, então você começa a trabalhar. Há uma corrida inicial, o que é ótimo, mas depois de alguns dias você começa a se perguntar se vale a pena. Você está tirando uma hora do seu dia para trocar de roupa e correr em uma roda de hamster e não tem certeza de que está realmente ganhando algo além de pernas e braços doloridos.

Então, depois de talvez uma ou duas semanas, quando a dor está acabando, um grande prazo começa a se aproximar. Você precisa passar todas as horas acordadas tentando realizar um trabalho "útil", para cortar coisas estranhas, como ir à academia. Você perde o hábito e, quando o prazo final termina, você volta à estaca zero. Se você conseguir voltar para a academia, sente-se tão dolorido quanto na primeira vez que foi.

Você faz algumas leituras para ver se está fazendo algo errado. Você começa a sentir um pouco de despeito irracional em relação a todas as pessoas felizes e em forma, exaltando as virtudes do exercício. Você percebe que não tem muito em comum. Eles não precisam dirigir 15 minutos para ir ao ginásio; há um em seu prédio. Eles não precisam discutir com ninguém sobre os benefícios do exercício; é apenas algo que todo mundo faz e aceita como importante. Quando um grande prazo se aproxima, eles não são informados de que o exercício é desnecessário, assim como seu chefe pedia para você parar de comer.

Portanto, para responder sua pergunta, o teste de unidade geralmente vale o esforço, mas a quantidade de esforço necessária não será a mesma para todos. Testes Unitários pode exigir uma quantidade enorme de esforço, se você está lidando com base de código espaguete em uma empresa que não faz realmente a qualidade do código de valor. (Muitos gerentes cantam os louvores ao teste de unidade, mas isso não significa que eles o defenderão quando for importante.)

Se você estiver tentando introduzir o teste de unidade em seu trabalho e não estiver vendo todo o sol e arco-íris esperados, não se culpe. Pode ser necessário encontrar um novo emprego para realmente fazer o Teste de Unidade funcionar para você.

A melhor maneira de convencer ... encontre um bug, escreva um teste de unidade para ele, corrija o bug.

É improvável que esse bug apareça novamente e você pode prová-lo com seu teste.

Se você fizer isso o suficiente, outros entenderão rapidamente.

thetalkingwalnut pergunta:

Quais são algumas boas maneiras de convencer os desenvolvedores céticos da equipe sobre o valor dos testes de unidade?

Todo mundo aqui vai se amontoar em muitas razões do nada porque o teste de unidade é bom. No entanto, acho que muitas vezes a melhor maneira de convencer alguém de alguma coisa é ouvir seu argumento e abordá-lo ponto a ponto. Se você os ouvir e ajudá-los a verbalizar suas preocupações, poderá abordar cada um deles e, talvez, convertê-los ao seu ponto de vista (ou, pelo menos, deixá-los sem uma perna para se apoiar). Quem sabe? Talvez eles o convencerão por que os testes de unidade não são adequados para sua situação. Não provável, mas possível. Talvez se você postar seus argumentos em testes de unidade, podemos ajudar a identificar os contra-argumentos.

É importante ouvir e entender os dois lados da discussão. Se você tentar adotar testes de unidade com zelo demais, sem levar em conta as preocupações das pessoas, você terminará em uma guerra religiosa (e provavelmente em testes de unidade realmente inúteis). Se você adotá-lo lentamente e começar aplicando-o onde obterá o maior benefício pelo menor custo, poderá demonstrar o valor dos testes de unidade e ter uma melhor chance de convencer as pessoas. Sei que isso não é tão fácil quanto parece - geralmente requer algum tempo e métricas cuidadosas para criar um argumento convincente.

Os testes de unidade são uma ferramenta, como qualquer outra, e devem ser aplicados de forma que os benefícios (captura de bugs) superem os custos (o esforço para escrevê-los). Não os use se / onde eles não fizerem sentido e lembre-se de que eles são apenas parte de seu arsenal de ferramentas (por exemplo, inspeções, asserções, analisadores de código, métodos formais, etc.). O que digo aos meus desenvolvedores é o seguinte:

1. Eles podem deixar de escrever um teste para um método se tiverem um bom argumento sobre por que não é necessário (por exemplo, simples demais para valer a pena ou difícil demais para valer a pena) e como o método será verificado de outra forma (por exemplo, inspeção, afirmações) , métodos formais, testes interativos / de integração). Eles precisam considerar que algumas verificações, como inspeções e provas formais, são feitas em um determinado momento e precisam ser repetidas sempre que o código de produção for alterado, enquanto testes de unidade e asserções podem ser usados ​​como testes de regressão (escritos uma vez e executados repetidamente posteriormente) ) Às vezes eu concordo com eles, mas com mais frequência debaterei se um método é realmente simples ou difícil demais para o teste de unidade.

   • Se um desenvolvedor argumentar que um método parece muito simples para falhar, não vale a pena gastar os 60 segundos necessários para escrever um teste de unidade de 5 linhas simples para ele? Essas 5 linhas de código serão executadas todas as noites (você constrói todas as noites, certo?) Durante o próximo ano ou mais e valerá a pena o esforço se, mesmo assim, ocorrer um problema que pode levar 15 minutos ou mais para identificar e depurar. Além disso, escrever os testes de unidade fáceis aumenta a contagem de testes de unidade, o que faz o desenvolvedor parecer bem.

   • Por outro lado, se um desenvolvedor argumentar que um método parece muito difícil para o teste de unidade (não vale o esforço significativo necessário), talvez seja uma boa indicação de que o método precisa ser dividido ou refatorado para testar as partes fáceis. Geralmente, esses são métodos que dependem de recursos incomuns, como singletons, a hora atual ou recursos externos, como um conjunto de resultados do banco de dados. Esses métodos geralmente precisam ser refatorados para um método que obtém o recurso (por exemplo, chama getTime ()) e um método que aceita o recurso como argumento (por exemplo, usa o registro de data e hora como parâmetro). Deixo que eles deixem de testar o método que recupera o recurso e, em vez disso, escrevem um teste de unidade para o método que agora utiliza o recurso como argumento. Geralmente, isso torna a escrita do teste de unidade muito mais simples e, portanto, vale a pena escrever.

2. O desenvolvedor precisa traçar uma "linha na areia" em como os testes de unidade devem ser abrangentes. Mais tarde no desenvolvimento, sempre que encontrarmos um bug, eles deverão determinar se testes de unidade mais abrangentes teriam detectado o problema. Nesse caso, e se esses erros surgirem repetidamente, eles precisam mover a "linha" para escrever testes de unidade mais abrangentes no futuro (começando com adicionar ou expandir o teste de unidade do bug atual). Eles precisam encontrar o equilíbrio certo.

É importante perceber os testes de unidade não são uma bala de prata e não é tal coisa a como demasiado testes de unidade. No meu local de trabalho, sempre que fazemos as lições aprendidas, inevitavelmente ouço "precisamos escrever mais testes de unidade". A gerência concorda com a cabeça, porque foi golpeado na cabeça deles que "testes de unidade" == "bom".

No entanto, precisamos entender o impacto de "mais testes de unidade". Um desenvolvedor pode escrever ~ N linhas de código por semana e você precisa descobrir qual porcentagem desse código deve ser código de teste de unidade versus código de produção. Um local de trabalho relaxado pode ter 10% do código como testes de unidade e 90% do código como código de produção, resultando em produtos com muitos recursos (embora muito problemáticos) (pense no MS Word). Por outro lado, uma loja rigorosa com 90% de testes de unidade e 10% de código de produção terá um produto sólido com muito poucas características (pense em "vi"). Você pode nunca ouvir relatórios sobre a falha do último produto, mas isso provavelmente tem muito a ver com o produto que não está vendendo muito bem e com a qualidade do código.

Pior ainda, talvez a única certeza no desenvolvimento de software seja que "a mudança é inevitável". Suponha que a loja estrita (90% de testes de unidade / 10% de código de produção) crie um produto com exatamente 2 recursos (assumindo 5% do código de produção == 1 recurso). Se o cliente aparecer e alterar 1 dos recursos, essa alteração prejudicará 50% do código (45% dos testes de unidade e 5% do código de produção). A loja relaxada (10% de testes de unidade / 90% de código de produção) possui um produto com 18 recursos, nenhum dos quais funciona muito bem. Seu cliente reformula completamente os requisitos de quatro de seus recursos. Embora a alteração seja quatro vezes maior, apenas metade da base de código é descartada (~ 25% = ~ 4,4% dos testes de unidade + 20% do código de produção).

O que quero dizer é que você precisa comunicar que entende o equilíbrio entre muito pouco e muito teste de unidade - essencialmente que você pensou nos dois lados da questão. Se você conseguir convencer seus colegas e / ou administrar isso, ganha credibilidade e talvez tenha mais chances de conquistá-los.

Eu brinquei com o teste de unidade várias vezes e ainda estou convencido de que vale a pena o esforço, dada a minha situação.

Eu desenvolvo sites, onde grande parte da lógica envolve a criação, recuperação ou atualização de dados no banco de dados. Quando tentei "zombar" do banco de dados para fins de teste de unidade, ele ficou muito confuso e parecia um pouco inútil.

Quando escrevi testes de unidade em torno da lógica de negócios, isso nunca me ajudou muito a longo prazo. Como em grande parte trabalho apenas em projetos, tenho a tendência de saber intuitivamente quais áreas do código podem ser afetadas por algo em que estou trabalhando e testá-las manualmente. Quero entregar uma solução para o meu cliente o mais rápido possível, e o teste de unidade geralmente parece uma perda de tempo. Listo os testes manuais e os passo pessoalmente, marcando-os enquanto vou.

Percebo que pode ser benéfico quando uma equipe de desenvolvedores estiver trabalhando em um projeto e atualizando o código um do outro, mas mesmo assim acho que, se os desenvolvedores forem de alta qualidade, uma boa comunicação e um código bem escrito devem ser suficientes .

Uma grande coisa sobre os testes de unidade é que eles servem como documentação de como seu código deve se comportar. Os bons testes são como uma implementação de referência, e os colegas de equipe podem vê-los para ver como integrar o código deles ao seu.

O teste de unidade vale bem o investimento inicial. Desde que comecei a usar o teste de unidade há alguns anos, encontrei alguns benefícios reais:

• teste de regressão elimina o medo de fazer alterações no código (não há nada como o brilho quente de ver o código funcionar ou explodir toda vez que uma alteração é feita)
• exemplos de código executável para outros membros da equipe (e para você dentro de seis meses ..)
• refatoração impiedosa - isso é incrivelmente gratificante, experimente!

Os trechos de código podem ser uma grande ajuda para reduzir a sobrecarga da criação de testes. Não é difícil criar trechos que permitam a criação de um esboço de classe e um acessório de teste de unidade associado em segundos.

Você deve testar o mínimo possível!

ou seja, você deve escrever apenas testes de unidade suficientes para revelar a intenção. Isso geralmente é encoberto. O teste de unidade custa você. Se você fizer alterações e precisar alterar os testes, ficará menos ágil. Mantenha os testes de unidade curtos e agradáveis. Então eles têm muito valor.

Muitas vezes, vejo muitos testes que nunca são interrompidos, são grandes e desajeitados e não oferecem muito valor, eles acabam atrasando você.

Eu não vi isso em nenhuma das outras respostas, mas uma coisa que notei é que eu poderia depurar muito mais rápido . Você não precisa fazer uma busca detalhada no seu aplicativo com a sequência correta de etapas para obter o código da sua correção, apenas para descobrir que cometeu um erro booleano e precisa fazer tudo novamente. Com um teste de unidade, você pode simplesmente entrar diretamente no código que está depurando.

[Eu tenho um ponto de fazer que eu não posso ver acima]

"Todos os testes de unidade, eles não necessariamente percebem isso - FATO"

Pense bem: você escreve uma função para talvez analisar uma string e remover novos caracteres de linha. Como desenvolvedor iniciante, você pode executar alguns casos através da linha de comando, implementando-o em Main () ou agrupar um front-end visual com um botão, amarrar sua função a algumas caixas de texto e um botão e ver o que acontece.

Isso é teste de unidade - básico e mal organizado, mas você testa o código em alguns casos.

Você escreve algo mais complexo. Ele lança erros quando você lança alguns casos (teste de unidade) e você depura o código e o rastreia. Você olha os valores à medida que avança e decide se eles estão certos ou errados. Este é um teste de unidade até certo ponto.

O teste de unidade aqui está realmente adotando esse comportamento, formalizando-o em um padrão estruturado e salvando-o para que você possa executar novamente facilmente esses testes. Se você escrever um caso de teste de unidade "adequado", em vez de manualmente, leva a mesma quantidade de tempo, ou talvez menos, à medida que você é experiente, e você tem disponível para repetir várias vezes

Durante anos, tentei convencer as pessoas de que elas precisavam escrever teste de unidade para seu código. Se eles escreveram os testes primeiro (como no TDD) ou depois de codificarem a funcionalidade, eu sempre tentei explicar a eles todos os benefícios de ter testes de unidade para código. Quase ninguém discordou de mim. Você não pode discordar de algo óbvio, e qualquer pessoa inteligente verá os benefícios do teste de unidade e do TDD.

O problema com o teste de unidade é que ele requer uma mudança de comportamento e é muito difícil mudar o comportamento das pessoas. Com palavras, você fará com que muitas pessoas concordem com você, mas não verá muitas mudanças na maneira como elas fazem as coisas.

Você tem que convencer as pessoas fazendo. Seu sucesso pessoal atrairá mais pessoas do que todos os argumentos que você possa ter. Se eles perceberem que você não está apenas falando sobre teste de unidade ou TDD, mas você estiver fazendo o que prega e for bem-sucedido, as pessoas tentarão imitá-lo.

Você também deve assumir uma função de liderança, porque ninguém escreve o teste de unidade da primeira vez, portanto, pode ser necessário treiná-los sobre como fazê-lo, mostrar o caminho e as ferramentas disponíveis para eles. Ajude-os enquanto eles escrevem seus primeiros testes, revise os testes que eles escrevem por conta própria e mostre-lhes os truques, expressões idiomáticas e padrões que você aprendeu com suas próprias experiências. Depois de um tempo, eles começarão a ver os benefícios por conta própria e mudarão de comportamento para incorporar testes de unidade ou TDD em sua caixa de ferramentas.

As mudanças não acontecerão durante a noite, mas com um pouco de paciência, você poderá alcançar seu objetivo.

Uma parte importante do desenvolvimento orientado a testes que geralmente é encoberto é a escrita de código testável. Parece um tipo de compromisso a princípio, mas você descobrirá que o código testável também é modular, sustentável e legível. Se você ainda precisar de ajuda para convencer as pessoas esta é uma apresentação simples e agradável sobre as vantagens dos testes de unidade.

Se a sua base de código existente não se presta a testes de unidade e já está em produção, você pode criar mais problemas do que resolver tentando refatorar todo o seu código para que possa ser testado por unidade.

É melhor você se esforçar para melhorar seus testes de integração. Há muito código por aí que é mais simples de escrever sem um teste de unidade, e se um controle de qualidade puder validar a funcionalidade em relação a um documento de requisitos, então você está pronto. Enviá-lo.

O exemplo clássico disso na minha mente é um SqlDataReader incorporado em uma página ASPX vinculada a um GridView. O código está todo no arquivo ASPX. O SQL está em um procedimento armazenado. O que você faz teste de unidade? Se a página faz o que deveria fazer, você deve realmente redesenhá-la em várias camadas para ter algo para automatizar?

Uma das melhores coisas sobre o teste de unidade é que seu código se tornará mais fácil de testar à medida que você o faz. O código preexistente criado sem testes é sempre um desafio, porque, como eles não deveriam ser testados em unidade, não é raro haver um alto nível de acoplamento entre classes, objetos difíceis de configurar em sua classe - como um e-mail referência de serviço de envio - e assim por diante. Mas não deixe isso te derrubar! Você verá que seu design geral de código se tornará melhor à medida que você começar a escrever testes de unidade e, quanto mais você testar, mais confiante estará em fazer ainda mais alterações, sem medo de interromper seu aplicativo ou introduzir bugs .

Há vários motivos para testar seu código de unidade, mas, à medida que o tempo avança, você descobrirá que o tempo economizado no teste é um dos melhores motivos para fazê-lo. Em um sistema que acabei de entregar, insisti em fazer testes de unidade automatizados, apesar das alegações de que eu gastaria muito mais tempo realizando os testes do que testaria manualmente o sistema. Com todos os meus testes de unidade concluídos, eu executo mais de 400 casos de teste em menos de 10 minutos, e toda vez que eu fazia uma pequena alteração no código, bastava ter certeza de que o código ainda estava funcionando sem bugs. minutos. Você pode imaginar o tempo que gastaria para executar manualmente esses mais de 400 casos de teste?

Quando se trata de testes automatizados - seja de unidade ou de aceitação - todos pensam que é um esforço desperdiçado codificar o que você pode fazer manualmente e, às vezes, é verdade - se você planeja executar seus testes apenas uma vez. A melhor parte dos testes automatizados é que você pode executá-los várias vezes sem esforço e, após a segunda ou terceira execução, o tempo e o esforço necessários. desperdiçou já são pagos.

Um último conselho seria não apenas testar seu código de unidade, mas começar a fazer o teste primeiro (consulte TDD e BDD para obter mais informações)

Os testes de unidade também são especialmente úteis quando se trata de refatorar ou reescrever um código de uma peça. Se você tiver uma boa cobertura de testes de unidade, poderá refatorar com confiança. Sem testes de unidade, muitas vezes é difícil garantir que você não quebrou nada.

Em suma - sim. Eles valem cada grama de esforço ... até certo ponto. No final das contas, os testes ainda são código e, assim como o crescimento típico do código, seus testes precisarão ser refatorados para serem mantidos e sustentáveis. Há uma tonelada de GOTCHAS! quando se trata de testes de unidade, mas cara, oh cara, oh cara, nada, e eu quero dizer NADA capacita um desenvolvedor a fazer alterações com mais confiança do que um rico conjunto de testes de unidade.

Estou trabalhando em um projeto agora ... é um pouco TDD, e temos a maioria de nossas regras de negócios encapsuladas como testes ... temos cerca de 500 testes unitários no momento. Na iteração passada, tive que renovar nossa fonte de dados e como nosso aplicativo de desktop se relaciona com essa fonte de dados. Demorei alguns dias, durante todo o tempo, continuei executando testes de unidade para ver o que quebrei e consertei. Faça uma mudança; Crie e execute seus testes; conserte o que você quebrou. Lave, enxágue, repita conforme necessário. Tradicionalmente, o que normalmente levava dias de controle de qualidade e muito estresse era uma experiência curta e agradável.

Prepare-se com antecedência, um pouco de esforço extra e pagará 10 vezes mais tarde quando você precisar começar a se interessar pelos recursos / funcionalidades principais.

Comprei este livro - é uma Bíblia com o conhecimento do xUnit Testing - é provavelmente um dos livros mais referenciados na minha estante e o consulto diariamente: link text

Ocasionalmente, eu ou um de meus colegas de trabalho passamos algumas horas chegando ao fundo de um bug ligeiramente obscuro e, uma vez que a causa do bug é encontrada 90% das vezes, o código não é testado em unidade. O teste de unidade não existe porque o desenvolvedor está cortando cantos para economizar tempo, mas perde essa e mais depuração.

Levar pouco tempo para escrever um teste de unidade pode economizar horas de depuração futura.

Estou trabalhando como engenheiro de manutenção de uma base de código mal documentada, terrível e grande. Desejo que as pessoas que escreveram o código tenham escrito os testes de unidade para ele.
Cada vez que faço uma alteração e atualizo o código de produção, tenho medo de introduzir um bug por não ter considerado alguma condição.
Se eles escrevessem o teste, fazer alterações na base de código seria mais fácil e rápido (ao mesmo tempo, a base de código estaria em um estado melhor).

Eu acho que os testes de unidade são muito úteis quando se escreve APIs ou frameworks que precisam durar muitos anos e serem usados ​​/ modificados / desenvolvidos por outras pessoas que não os codificadores originais.

O teste de unidade definitivamente vale o esforço. Infelizmente, você escolheu um cenário difícil (mas infelizmente comum) para implementá-lo.

O melhor benefício dos testes de unidade que você obtém é ao usá-lo desde o início - em alguns projetos selecionados e pequenos, tive a sorte de escrever meus testes de unidade antes de implementar minhas aulas (a interface já estava completa neste ponto). Com testes de unidade adequados, você encontrará e corrigirá erros em suas aulas enquanto eles ainda estão na infância e nem perto do sistema complexo em que, sem dúvida, serão integrados no futuro.

Se o seu software for solidamente orientado a objetos, você poderá adicionar testes de unidade no nível da classe sem muito esforço. Se você não tiver essa sorte, ainda deve tentar incorporar o teste de unidade sempre que puder. Certifique-se de que ao adicionar nova funcionalidade, as novas peças sejam bem definidas com interfaces claras e você encontrará testes de unidade que tornam sua vida muito mais fácil.

Quando você disse, "nossa base de código não se presta a testes fáceis" é o primeiro sinal de um cheiro de código. Escrever testes de unidade significa que você normalmente escreve código de maneira diferente para tornar o código mais testável. Isso é bom, na minha opinião, porque o que eu vi ao longo dos anos escrevendo código para o qual eu tinha que escrever testes me forçou a apresentar um design melhor.

Eu não sei. Muitos lugares não fazem teste de unidade, mas a qualidade do código é boa. A Microsoft faz teste de unidade, mas Bill Gates deu uma tela azul em sua apresentação.

Eu escrevi um post muito grande sobre o assunto. Descobri que o teste de unidade por si só não vale o trabalho e geralmente é cortado quando os prazos se aproximam.

Em vez de falar sobre o teste de unidade do ponto de vista da verificação "teste após", devemos examinar o valor verdadeiro encontrado quando você decide escrever uma especificação / teste / idéia antes da implementação.

Essa idéia simples mudou a maneira como escrevo software e não voltaria à maneira "antiga".

Como o desenvolvimento do primeiro teste mudou minha vida

Sim - o teste de unidade definitivamente vale a pena, mas você deve saber que não é uma bala de prata. O teste de unidade é um trabalho e você terá que trabalhar para manter o teste atualizado e relevante à medida que o código for alterado, mas o valor oferecido vale o esforço que você deve colocar. A capacidade de refatorar com impunidade é um grande benefício, pois você sempre pode validar a funcionalidade executando seus testes após qualquer código de alteração. O truque é não se prender a exatamente a unidade de trabalho que você está testando ou como você está executando os requisitos de teste e quando um teste unitário é realmente um teste funcional etc. As pessoas discutem sobre isso por horas por fim, e a realidade é que qualquer teste que você faz como seu código de gravação é melhor do que não fazê-lo. O outro axioma é sobre qualidade e não quantidade - vi bases de código com 1000 ' s de teste que são essencialmente sem sentido, pois os demais não testam realmente nada de útil ou qualquer domínio específico, como regras de negócios, etc. do domínio em particular. Também vi bases de código com 30% de cobertura de código, mas os testes foram relevantes, significativos e realmente impressionantes, pois testaram a funcionalidade principal do código para o qual foi escrito e expressaram como o código deve ser usado.

Um dos meus truques favoritos ao explorar novas estruturas ou bases de código é escrever testes de unidade para descobrir como as coisas funcionam. É uma ótima maneira de aprender mais sobre algo novo em vez de ler um documento seco :)

Recentemente, passei exatamente pela mesma experiência no meu local de trabalho e descobri que a maioria deles conhecia os benefícios teóricos, mas precisava ser vendida especificamente, então aqui estavam os pontos que usei (com sucesso):

• Eles economizam tempo ao executar testes negativos, onde você lida com entradas inesperadas (ponteiros nulos, valores fora dos limites etc.), pois você pode fazer tudo isso em um único processo.
• Eles fornecem feedback imediato em tempo de compilação sobre o padrão das alterações.
• Eles são úteis para testar representações de dados internos que podem não ser expostas durante o tempo de execução normal.

e o grande ...

• Você pode não precisar de testes de unidade, mas quando alguém entra e modifica o código sem um entendimento completo, ele pode pegar muitos dos erros tolos que eles podem cometer.

Descobri o TDD há alguns anos e, desde então, escrevi todos os meus projetos de estimação usando-o. Estimei que leva quase o mesmo tempo para TDD um projeto que o necessário para criar um cowboy juntos, mas tenho tanta confiança no produto final que não consigo evitar um sentimento de realização.

Eu também acho que isso melhora meu estilo de design (muito mais orientado à interface, caso eu precise zombar das coisas) e, como escreve o post verde na parte superior, ajuda com a "constipação de codificação": quando você não sabe o que para escrever a seguir, ou se tiver uma tarefa assustadora à sua frente, você pode escrever pequeno.

Finalmente, acho que, de longe, a aplicação mais útil do TDD está na depuração, mesmo que você já tenha desenvolvido uma estrutura de interrogatório com a qual você pode estimular o projeto a produzir o bug de forma repetível.

Uma coisa que ninguém mencionou ainda é obter o compromisso de todos os desenvolvedores de executar e atualizar qualquer teste automatizado existente. Os testes automatizados para os quais você volta e encontra com problemas devido ao novo desenvolvimento perdem muito valor e tornam os testes automatizados realmente dolorosos. A maioria desses testes não indica erros, pois o desenvolvedor testou o código manualmente, portanto, o tempo gasto para atualizá-los é apenas um desperdício.

Convencer os céticos a não destruir o trabalho que os outros estão fazendo nos testes de unidade é muito mais importante para obter valor com os testes e pode ser mais fácil.

Passar horas atualizando testes interrompidos devido a novos recursos cada vez que você atualiza a partir do repositório não é produtivo nem divertido.

Se você estiver usando o NUnit, uma demonstração simples, mas eficaz, é executar o (s) próprio (s) conjunto (s) de teste do NUnit na frente deles. Ver uma suíte de testes real, a treinar uma base de código, vale mais que mil palavras ...

O teste de unidade ajuda muito em projetos maiores do que qualquer desenvolvedor pode ter em sua cabeça. Eles permitem que você execute o conjunto de testes de unidade antes de fazer o check-in e descubra se você quebrou alguma coisa. Isso diminui bastante as instâncias em que você precisa sentar e mexer os polegares enquanto espera que outra pessoa corrija um bug que eles fizeram check-in, ou ir ao trabalho de reverter as alterações para que você possa fazer algum trabalho. Também é imensamente valioso na refatoração, para que você possa ter certeza de que o código refatorado passa em todos os testes que o código original fez.

Com o conjunto de testes de unidade, é possível fazer alterações no código, deixando o restante dos recursos intactos. É uma grande vantagem. Você usa o teste de unidade e o conjunto de testes de regressão sempre que terminar de codificar o novo recurso.

Estou de acordo com o ponto de vista oposto à maioria aqui: não há problema em escrever testes de unidade É especialmente difícil combinar programas pesados ​​com protótipos (IA, por exemplo) com testes de unidade.