A equipe de novatos de testes de unidade precisa fazer o teste de unidade

Estou trabalhando com uma nova equipe que historicamente não realizou QUALQUER teste de unidade. Meu objetivo é que a equipe eventualmente empregue o TDD (Test Driven Development) como processo natural. Mas como o TDD é uma mudança radical de mente para uma equipe que não é de unidade, pensei em começar a escrever testes de unidade após a codificação.

Alguém esteve em uma situação semelhante? Qual é uma maneira eficaz de fazer uma equipe se sentir confortável com o TDD quando não realizou nenhum teste de unidade? Faz sentido fazer isso em algumas etapas? Ou devemos mergulhar e enfrentar todas as dores de crescimento de uma só vez?

EDITAR

Apenas para esclarecimento, não há ninguém na equipe (além de mim) que tenha QUALQUER exposição / experiência em testes de unidade. E estamos planejando usar a funcionalidade de teste de unidade incorporada ao Visual Studio.

Prática em bugs / defeitos existentes.

Esta é uma situação muito difícil. Eu nunca tinha ido ao TDD do nada antes, mas, na minha experiência, conseguir que uma equipe passe de nenhum teste de unidade para escrevê-los proativamente tem sido uma abordagem muito "um passo de cada vez".

Primeiro, faça com que eles se sintam à vontade para escrever testes de unidade e saber realmente o que são e seus benefícios. Para minhas equipes, é melhor escrever testes de unidade para erros existentes. Os erros atuais nos sistemas têm duas coisas que você precisa ensinar às pessoas para escrever bem os testes de unidade:

1. uma pré-condição e pós-condição esperada
2. um resultado que atualmente não é o esperado e viola essa pré-condição / pós-condição

Isso dá aos membros exemplos de práticas muito concretas. Eles podem escrever um teste antes de corrigir o bug, para que ele falhe. Em seguida, eles podem corrigir o código para que ele passe e corrige o erro. Uma vez que eles se sintam confortáveis ​​com isso, você poderá levá-los até o fim, para que eles possam escrever testes de unidade sem código antecipado e, em seguida, escrever um novo código para que seus testes sejam aprovados.

Eu acho que o truque é dar a eles algo para praticar onde existem métodos claros pré / pós-condições. Se os requisitos de métodos são imprecisos, é difícil até mesmo pessoas experientes em TDD saberem exatamente por onde começar. Dê um passo no tempo e você chegará lá. Boa sorte!

Consegui convencer toda a minha empresa a mudar para TDD. Não foi fácil, mas valeu a pena o esforço: a qualidade do código aumentou após a transição e agora ninguém imagina voltar aos horríveis tempos de codificação de cowboys.

1. Explique, explique, explique. Você não quer que sua equipe escreva testes. Você quer que sua equipe queira escrever testes. Isso significa que eles devem entender completamente por que devem fazê-lo, quais são os benefícios e como isso facilitará seu trabalho. Vermelho, Verde, Refatorar , escrever um teste de regressão como prova de que um bug foi corrigido etc. Você precisa convencê-los de que tudo faz sentido antes de pedir que escrevam qualquer código.

2. Vá para a coisa real (primeiros testes e depois código). Escrever testes após o código dificilmente faz sentido, pois você nunca saberá se eles realmente funcionam (e as pessoas escrevem casos de teste de buggy). Minha intuição é que a quantidade de esforço que você precisa para passar de nenhum teste para primeiro é muito menor do que o necessário para não formar nenhum teste através do código primeiro para testes primeiro , então você também pode pular a etapa intermediária.

3. Comece com testes de regressão. Eles são bem simples de entender e oferecem gratificação instantânea. Obviamente, isso pressupõe que o código seja modularizado adequadamente e facilmente testável. Caso contrário, pule esta etapa.

4. Dê passos de bebê. O TDD leva algum tempo para se acostumar e pode ser frustrante a princípio. Tente introduzir testes em um novo projeto ou componente, idealmente: algo não muito importante. Você deseja evitar a todo custo a situação em que algo realmente importante deve ser feito rapidamente, e os programadores sentem que o TDD está atrapalhando.

5. Quando a equipe começar a se sentir confortável, tenha todas as novas funcionalidades escritas de maneira TDD. Isso depende do tamanho do seu projeto, mas depois de algum tempo você deve obter uma cobertura muito boa, com apenas algumas partes herdadas do seu projeto escritas da maneira antiga.

6. Nesse ponto, a equipe já deve entender e adotar o TDD, e o material legado (não TDD) deve ser considerado difícil e irritante de se trabalhar. Reformule-o: a maioria das pessoas o faz com prazer.

Alguns outros pontos importantes:

• Verifique se você está usando a melhor estrutura de teste disponível. Será muito mais difícil convencer as pessoas a fazer TDD se elas tiverem que interagir com uma biblioteca que está mal escrita.

• Verifique se os testes são fáceis de executar e não demoram muito tempo para concluir (ou trapaceie, por exemplo, usando um banco de dados na memória para os testes).

• Configure algum software de integração contínua, para que testes quebrados sejam encontrados imediatamente.

Uma maneira de se acostumar com o TDD é escrever primeiro os testes de integração. Introduzir costuras de teste e testes de unidade verdadeiros posteriormente.

O problema ao escrever testes de unidade após a codificação é que o código pode não ser necessariamente bem projetado para ser testável . Pode ser necessário refatorar ou refazer o design para introduzir as costuras de teste. Mas como você pode refatorar ou reprojetar com segurança se você não possui cobertura de teste de qualquer tipo?

Os testes de integração podem fornecer essa cobertura inicialmente. Sempre que houver um problema de regressão ou produção, corrija-o no código e cubra-o com um teste. Depois que você tiver uma rede de segurança suficiente fornecida por esses testes, poderá introduzir testes de unidade de componentes isolados e mais refinados e / ou classes do seu sistema.

O TDD é muito difícil de implementar e nem sempre é a melhor opção para todas as equipes de desenvolvimento. No meu trabalho anterior, a equipe estava fortemente focada no TDD. Nosso modelo de desenvolvimento foi inteiramente TDD usando a abordagem de desenvolvimento ágil. O teste foi realizado através de testes de unidade do Visual Studio.

Se um desenvolvedor não escrevesse nenhum teste de unidade para seu recurso, ele estaria com problemas com o líder técnico. Além disso, se alguém fizer check-in de uma compilação quebrada ou qualquer teste de unidade, o desenvolvedor precisará corrigir todos os problemas e adicionar $ 1 ao dinheiro da equipe.

Apenas uma pequena coisa a acrescentar, visualize o processo. Faça a integração contínua executar testes automaticamente e verifique a cobertura do código. Liste os módulos testados mais completos em alguma página inicial que todos possam ver. Isso deve dar início à competição por equipes.

Passei de nenhuma experiência JUnit diretamente para TDD, e a experiência tornou o valor do TDD inconfundivelmente aparente. Fiquei tão agradecido pelos testes de unidade que rapidamente me tornei um evangelista pela abordagem

Eu estive em equipes que não fizeram nenhum teste de unidade, mas foi introduzido e tornou-se quase comum fazer alguns testes agora. Eu sugeriria que você explorasse até que ponto sua equipe entende os conceitos básicos de teste de unidade e quais ferramentas você deseja trazer aqui?

No meu caso, estava trazendo o nUnit para algum código .Net que era uma mistura de lógica comercial, interface do usuário e funcionalidade de back-end. Eu sugeriria ver se há pessoas mais dispostas a querer mais do que outras, para que algumas pessoas da equipe o entendam, e isso pode se espalhar um pouco melhor do que o outro lado, onde você tenta obter todo mundo para pular sobre isso. Ao fazer com que alguns o façam bem primeiro, isso possibilita algum treinamento cruzado, para que aqueles que o adquirem possam ser testados quanto ao quanto eles podem ensiná-lo a outra pessoa.

Outro ponto é considerar trazer aqueles que têm mais experiência para tentar mostrar isso em certa medida. O Thoughtworks foi trazido para onde eu trabalho para mostrar algumas coisas que algumas delas foram amplamente adotadas e outras nem tanto, mas acho que isso seria verdade na maioria dos lugares.