Tag Archives: testes automatizados

Dica #6: Escrevendo testes fluentes


Aqui vai uma dica rápida. Quando comecei a escrever meus primeiros testes automatizados eu tinha algo assim.

int actual = calculadora.Somar(1 +2);
int expected = 3;
Assert.AreEquals(expected, actual);

Após um tempo, comecei a ganhar mais experiência e aprendi algo chamado de Fluent Interfaces. O objetivo desta “técnica” é escrever código que seja fácil de ler. O código acima é fácil, correto? Mas da para melhor, quer ver?

Veja este exemplo aqui.

int actual = calculadora.Somar(1 +2);
Assert.That(actual, Is.EqualTo(3));

Melhorou, não acha? Legibilidade faz parte do Clean Code e Fluent Interfaces é uma excelente técnica que pode te ajudar a deixar seu código mais fácil de ler. Reserve um tempo e procure entender melhor como funciona. Além disso, a partir do C# 3.0 tivemos a adição das Closures que também é outro recurso poderosísimo na busca pela Legibilidade.

Nota: Estes exemplos acima foram construidos com NUnit e já vem pronto, não sendo necessário adicionar dependência para nenhuma outra biblioteca. No caso do MSUnit, eu recomendo o Sharp Tests Ex, que alías também funciona com o NUnit.

É isso ai e até a próxima.

Conselho do Tio Bob

Esse vídeo foi gravado já faz um tempo pelo Fabio Akita e foi postado no blog dele. Eu acho este vídeo tão bom que resolvi colocá-lo aqui, talvez alguém ainda não tenha visto.

100% de Code Coverage?

De forma simplificada,  o code coverage é uma métrica usada em testes automatizados que aponta o percentual de linhas de código que estão sendo cobertas pela suite de teste. Ter 100% de coverage significa que toda linha do seu código de produção está sendo executada pelo menos uma vez.

Sabendo disto, lhe pergunto, o que você ganha ao atingir 100%?

Ter um software com 100% de cobertura de testes não significa que seu software é bug-free e muito menos que ele é melhor que um software que possui apenas 80%. Além disso, eu poderia até dizer que 100% de cobertura é quase impossível. Nos projetos em que eu tentei cobertura total, geralmente eu conseguia no máximo 95% usando testes um tanto quanto inúteis, apenas para aumentar o percentual. O maior problema ao estabelecer uma meta de 100% é que seu foco ao escrever um teste acaba se voltando para atender esta meta, e não mais para testar um requisito.

Um adepto de TDD geralmente terá perto de 90% de coverage. Porquê? Porque se você escreve o teste antes, ao codificar o código de produção você fará apenas o necessário para o teste passar, nem uma linha de código a mais, nem a menos, ou seja, 100%. Em todo caso, por algum motivo de seu framework ou linguagem, você é obrigado a escrever algumas linhas não esperadas no seu teste, e isso vai fazer seu coverage baixar, por isso o 90%.

Eu não tenho o costume de verificar o coverage constantemente, executo apenas uma vez ou outra para ter uma idéia de como está a situação. Se está muito baixo, e eu considero baixo até 80%, eu busco encontrar o que está baixando tanto assim minha coberturda. As vezes é porque um método que foi criado e que não é mais utilizado ainda está dentro de uma classe, ou então uma classe que por algum motivo eu esqueci de testar. Enfim, para mim, 80% ~ 100% é um valor aceitável.

Para quem nunca usou code coverage em C#, eu recomendo baixar o plugin TestDriven.Net que já vem com diversos frameworks de teste como MbUnit e NUnit além do NCover.

Veja abaixo uma imagem das informações mostradas pelo NCover. Aquele percentual vermelho ali mostra que apenas X% das linhas daquela classe estão sendo executadas no teste. Por exemplo a classe CodeUtil (0%), não possui teste nenhum.

Livro: Clean Code, A Handbook of Agile Software Craftsmanship

Sabe aqueles livros que você lê e não para? Então, aconteceu isso comigo ao ler este, Clean Code é um dos poucos livros que dei nota 5 no shelfari.

Martin_MECH.qxd

O primeiro cápitulo é um dos pontos chaves da leitura, ele fala sobre as vantagens de um código limpo, e porquê você deveria se preocupar com isso. Mesmo que um trecho de código compile e funcione da maneira esperada ( certificando-se através de testes unitários )  pode ser ser considerado ruim, legado e mal escrito. O problema é que é muito difícil manter um código limpo, toda a equipe precisa estar ciente dos ganhos que isso pode trazer, e basta uma pessoa violar as regras e o código já vira um carnaval. O que acontece geralmente é que a primeira versão de um componente é desenvolvido de forma clara e bem escrito, nas manutenções subseqüentes as primeiras sujeiras começam a ser inseridas até o momento que vira um monstro onde ninguémtem coragem de tocar.

Nos Estados Unidos as reservas florestais possuem uma regra que diz: “Leave the campground cleaner than you found it”. Imagine isso em um ambiente de desenvolvimento de software, não seria o máximo ter um projeto que o código está sempre mais limpo do que ontem?

Não sei exatamente o que leva algumas empresas a não se preocupar com as boas práticas, é fato que a maior parte dos problemas ocorrem na fase de análise de sistemas, uma análise errada pode resultar em um software inútil, assim como uma ótima análise é um péssimo código resulta em um sistema com os dias contados, daqui 2 ou 3 anos vai sair mais barato fazer outro do que dar manutenção no sistema “legado”. No final quem ganha com isso são as Fábricas de Software, no final do mês são mais horas contratadas, enquanto isso o pobre cliente está lá investindo em algo que logo morre.

wtf-per-minute

Talvez você não tenha como mudar as coisas na sua empresa, mas faça sua parte, limpe o acampamento antes de fazer check-in, tudo bem que um urso pode vir e destruir seu código, mas pelo menos você fica com a consciência limpa de que fez o que era certo.

Como escrever um código clean?

Sugiro a leitura do livro, ele trata sobre nomenclatura de métodos, classes e variáveis, comentários, funções, tamanho da função e responsabilidades (SRP). Dentre outros assuntos, também fala sobre testes automatizados, vejam que esse assunto está presente em todo lugar.

Não adianta ler e achar que vai virar um ninja, é claro que depois de terminar você já vai ter aprendido diversos truques, mas os mais as práticas mais elaboradas precisam de tempo e prática. Na teoria é tudo muito bonito e aparentemente fácil, quando você coloca a mão na massa você percebe que não é tão fácil e que requer muito estudo.

Segue mais alguns links interessantes sobre o assunto:

Testes automatizados

A idéia por trás de usar testes automatizados é possuir uma maneira rápida de se testar uma determinada aplicação. A etapa de testes em um processo tradicional de desenvolvimento de software é feitos após a conclusão da construção e, geralmente, feito de forma manual, o problema nesse caso é que é algo excessivamente repetitivo, caro, demorado e incerto. Quando você testa alguma rotinha do sistema e verifica que ela está ok, dificilmente você vai voltar nela para re-testar, pois você presume que não vai ter problema, afinal, você já o testou. Isso é normal e muito comum, é um trabalho muito chato ter que testar todo o sistema toda vez que fizer alguma alteração.

Produtividade elevada

Produtividade elevada

Uma maneira de resolver esse problema é fazendo com que o computador teste para você, ele é muito mais rápido, barato, não torna seu trabalho repetitivo, pois não requer interferência do usuário e usando algumas métricas como Code Coverage você consegue ter uma lista de testes que te dê uma certeza do que foi e o que não foi testado.

Estes testes são escritos na forma de código fonte pelo próprio programador que escreveu a rotina a ser testado, uma técnica muito famosa nessa área é chamado de TDD que sugere que os testes sejam escritos antes do programa em si, existem vantagens significativas no uso desta prática, mas não vou entrar nesse assunto.

Outra prática muito interessante é a de Integração Contínua, onde você tem um ambiente que gera um deploy completo do seu código, executa sua suíte de testes e te deixa informado sobre os resultados. Se der certo, o produto está pronto para ser colocado em produção livre de bugs. Aqui vale uma observação, testes funcionando não significam que seu software não tem bug, mas te deixa ciente de que todos os bugs conhecidos e já testados nunca mais vão ocorrer novamente.

É comum pensar que ao utilizar testes automatizados não iremos mais precisar de uma área de testes, na minha opinião isso está errado e a área ganha ainda mais significado, ela precisa encontrar bugs, quanto mais bugs que ela encontrar, melhor. Todos esses bugs devem ser passados para a equipe de desenvolvimento que vai se responsabilizar de simular o erro usando testes automatizados, isso vai garantir que o mesmo bug nunca mais ocorra.

Quer saber mais sobre? Sugiro a leitura dos seguintes links, alguns conceituais e outros com exemplo de implementação. Se você trabalha com .Net e quiser aprender TDD, sugiro a leitura deste meu post.

Livro: Test-Driven Development in Microsoft .NET

Test Driven Development in Microsoft .NETTDD é uma técnica de desenvolvimento de software onde você escreve seus testes antes de escrever o código da aplicação. Parece estranho, não? Como você vai testar algo que ainda não está pronto?

Depois de muita leitura em blogs e outros sites, eu ainda não havia conseguido achar uma resposta para esta pergunta, apelei então para um livro, e no meu caso foi o Test Driven Development in Microsoft .NET.

Eis que para minha felicidade, achei a resposta no primeiro capítulo, você escreve o teste com o intuito de ditar como vai ser o comportamento da sua aplicação, e não para ver se está funcionando. O mais interessante é que se você levar essa técnica a sério, no final do projeto você vai ter uma documentação executável e uma suite de testes automatizadas bem completa.

Além de uma introdução ao TDD, o livro fala sobre o famoso Red/Green/Refactor, customer tests e um exemplo completo de uma aplicação construída com TDD, usando ADO.NET e Web Services. Eu particularmente gostei muito do primeiro capítulo, já o segundo ficou bem cansativo de ler, há muito código nele, sem contar o uso de DataSets (não sou muito fã deles).

Essa é uma técnica que eu recomendo muito, a comunidade de Ruby on Rails faz uso constante de TDD e BDD, o que é muito legal, acho que já virou algo natural para eles. Logo mais vou falar sobre testes automatizados, que tem tudo a ver com o assunto do livro.

Compilando suas views no ASP.NET MVC

Uma das vantagens em se utilizar uma linguagem compilada é que alguns erros de digitação são pegos no processo de compilação e não somente quando você executa a aplicação. No ASP.NET MVC as views não são compiladas ao fazer o build no visual studio e, portanto, estão sujeitas a ter tais erros. O problema mais comum é quando você faz um Refactor -> Rename em uma de suas classes, o visual studio NÃO vai renomear essas classes em suas views, e você só vai notar o erro quando estiver nagendo na página. Para que o visual studio compile suas views, e consequentemente, resolva o problema citado, siga os passos:

  1. Com o notepad, abra o arquivo *.csproj ou *.vbproj da sua aplicação MVC.
  2. Procure a tag <PropertyGroup> e antes de fechá-la (</PropertyGroup>), adicione o seguinte conteúdo: <MvcBuildViews>true</MvcBuildViews>.

Existem várias tags PropertyGroup e cada uma deles corresponde a uma configuração de build dentro do visual studio (Debug/Release), utilize aquela que você achar melhor ou então insira dentro de todas elas. Feito isso, os problemas encontrados serão listados na aba Error List.

So far, so good

Compiling!

Só tem um porém, você vai sentir um enorme delay no build, o tempo de compilação quase triplica.

Quando se está trabalhando em um projeto pequeno não fará tanta diferença, agora quando seu projeto for muito grande, você pode optar por esperar enquanto toma um café, brincar de “lutinha” com seu amigo de trabalho ou pedir para seu chefe um servidor de integração contínua.

No caso de optar pela última opção (a melhor delas, mesmo gostando da segunda), você pode deixar para compilar suas views uma vez por dia caso demore muito.

É importante lembrar que uma aplicação compilada não significa que está funcionando, a melhor maneira de saber é rodando testes automatizados, logo TATFT.

Sharing Buttons by Linksku