Práticas recomendadas de teste de unidade para um novato em teste de unidade

Nos últimos anos, escrevi apenas pequenos componentes para pessoas em projetos maiores ou pequenas ferramentas. Eu nunca escrevi um teste de unidade e sempre parece aprender a escrevê-los e realmente fazer com que um demore muito mais do que simplesmente iniciar o programa e testar de verdade.

Estou prestes a iniciar um projeto de larga escala que pode levar alguns meses para ser concluído e, enquanto tentarei testar os elementos enquanto os escrevo (como sempre), estou me perguntando se o teste de unidade poderia me economizar tempo.

Eu só queria saber se alguém poderia dar bons conselhos:

1. Eu deveria estar olhando para os testes de unidade no início do projeto e, possivelmente, adotar uma abordagem de TDD.
2. Devo apenas escrever testes à medida que avanças, após cada seção ser concluída.
3. Devo concluir o projeto e depois escrever testes de unidade no final.

Alguns dirão o contrário, mas eu sugiro que você separe o TDD e o Teste de unidade. O TDD é uma mudança mental e o teste de unidade parece inicialmente levar tempo. Se você os considera um item, existe o risco de você não receber benefícios suficientes imediatamente e haverá a tentação de simplesmente abandonar o TDD e o Teste de Unidade com ele.

A primeira coisa é escrever alguns testes de unidade. Eles não precisam ser perfeitos no começo. Apenas ensine a si mesmo como testar pequenas unidades de código e como usar simulação para isolar componentes.

Este é o maior tomador de tempo, mas tem de longe o maior retorno. Depois que você perceber que não precisa mais percorrer 14 páginas da Web para acessar a que deseja testar, saberá do que estou falando.

Para mim, o grande momento Eureka foi um aplicativo do Windows em que eu estava tentando testar uma regex, que exigia o preenchimento de dois formulários antes que eu pudesse acessá-lo. Instalei o NUnit e escrevi um teste em torno desse método e vi com que rapidez economizava horas de tempo de teste. Depois, adicionei mais testes para lidar com os casos extremos. E assim por diante.

Então aprenda a escrever bem os testes de unidade. Aprenda o equilíbrio entre testes frágeis, que são rápidos para escrever e escrever muitos testes individuais. Isto é bastante fácil. A lição é que, idealmente, cada teste testa apenas uma coisa, mas você aprende rapidamente quanto tempo leva, então começa a se intrometer um pouco na regra até escrever um teste que quebra em cada alteração de código e depois volta ao equilíbrio certo (que é mais próximo do anterior que o último).

TDD é, como eu disse, uma grande mudança mental na maneira de trabalhar. No entanto, isso não adicionará muito tempo ao seu processo de desenvolvimento, uma vez que você já está escrevendo testes. E prometo que você verá seu estilo de codificação melhorar diante de seus olhos. Ou melhor, se você não largá-lo, não é para você.

Uma última coisa a ter em mente é que o TDD não se limita aos testes de unidade. O design orientado para o teste de aceitação faz parte do TDD. Outro bom motivo para não misturá-los em sua mente.

Eu concordo com os outros (definitivamente não escreva seus testes no final, o TDD leva tempo para aprender, comece com os testes da maneira que puder, mire no TDD completo eventualmente). Mas queria acrescentar uma coisa em resposta ao seu comentário: "Estou pensando se o teste de unidade poderia me poupar tempo".

Minha resposta é um inequívoco sim. Aprendi a abordagem TDD há cerca de 10 anos, após um período de tempo semelhante codificando sem testes. Hoje em dia, se eu estiver fazendo algo curto (<250 loc) e simples, ou algo descartável, não o TDD. Caso contrário, sim, e precisamente porque economiza tempo.

A economia de tempo ocorre de três maneiras: menos WTF, menos depuração e menos medo. O primeiro é óbvio: você passa muito menos tempo se perguntando o que diabos a coisa que você construiu está fazendo. Quando você tem um problema, a depuração é muito mais fácil, porque: a) você pega bugs testados instantaneamente eb) bugs não testados têm menos lugares para se esconder.

A coisa menos medo, porém, é mais sutil. Até você passar um tempo em uma base de código TDD, você nem percebe quanto tempo gasta se preocupando com as alterações que está fazendo. X funciona? Será que vai quebrar Y? Existe algum Z que pode ser afetado? Com o TDD, isso desaparece, porque você transforma seus medos em testes e o computador automatiza a preocupação. Um desenvolvedor mais corajoso é um desenvolvedor mais rápido.

1. Devo olhar a unidade no início e adotar uma abordagem TDD.

2. Devo apenas escrever testes à medida que cada seção é concluída.

Qualquer um desses, mas não a terceira opção .

Como o @pdr observou, aprender o teste de unidade adequado leva tempo. Você definitivamente quer ter tempo para aprender no início do ciclo de vida do projeto, não no final, quando o prazo está chegando à sua cabeça. Dessa forma, você já está atualizado e pode até começar a colher os benefícios no momento em que o prazo se aproxima, devido a ter detectado a maioria dos erros no início do ciclo de vida do projeto.

Observe que o primeiro teste de unidade é sempre o mais difícil, especialmente se você estiver testando o código já escrito. Esse código pode não ser amigável ao teste de unidade; portanto, você pode ter dificuldade em conectar todos os objetos com o estado adequado para o teste. Assim, escolha alguns testes fáceis, bastante isolados e de baixo nível para suas primeiras tentativas de teste de unidade, e gradualmente você poderá aumentar o nível de desafio. Quando o primeiro equipamento de teste estiver pronto, o próximo caso de teste será muito mais fácil e, quando você chegar ao quarto, estará produzindo casos de teste, como em uma correia transportadora. É quando você começa a sentir a bondade de poder repetidamente, comprovadamente provar que seu código funciona ...

Pessoalmente, prefiro a abordagem TDD e não acho que seja tão desafiador - é preciso perseverança, mas acredito que quanto mais cedo você começar com TDD, mais cedo começará a ver os benefícios dos testes de unidade em geral. No entanto, pode ser que os primeiros testes de unidade sejam melhores para escrever o código que você já possui. Então, depois de entender o que está acontecendo, comece a experimentar o TDD.

Eu acho que a melhor coisa para um novato é lidar com alguns katas de código que se prestam a testes de unidade. Por exemplo; validando um endereço de email. O TDD se torna o fluxo natural quando você enfrenta alguns desses códigos Katas. Confira o seguinte kata de código para o validador de endereço de email que mencionei: Validador de email

Para obter uma explicação do que o Code Katas é para aqueles que não sabem, confira o seguinte link: Code Katas