Artigo .net Magazine 36 - Testes no Visual Studio 2005

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (0)  (0)

Artigo publicado pela .net Magazine 36.

capa_NET36_G.gif

Clique aqui para ler todos os artigos desta edição

Testes no Visual Studio 2005

 

Este artigo discute

Este artigo usa as seguintes tecnologias

·                               Testes unitários;

·                               Classes de testes;

·                               Metodologias Agile;

·                               Refactoring.

Visual Studio 2005, C# e NUnit.

 

Com o aparecimento e a popularização de metodologias Agile de programação, como o XP (eXtreme Programming) e o MSF (Microsoft Solutions Framework), tornou-se indispensável ao desenvolvedor moderno conhecer técnicas para melhorar seu desenvolvimento e gerenciar grandes volumes de código eficientemente, evitando falhas e bugs no caminho.

Essas técnicas envolvem, principalmente, dois conceitos: refactoring e testes. O refactoring consiste em reescrever o código para torná-lo mais simples, mais escalável e mais fácil de manter, enquanto o desenvolvimento Orientado a Testes é uma técnica que prega a criação de testes antes da criação da rotina propriamente dita, minimizando a possibilidade de ocorrência de falhas no programa. 

Neste artigo, exploraremos o desenvolvimento Orientado a Testes no .NET Framework e mostraremos como executá-lo no Visual Studio 2005.

 

O que é desenvolvimento Orientado a Testes?

Sem dúvida, em algum momento do desenvolvimento, o desenvolvedor tem que fazer testes para assegurar que o código funciona como esperado. No entanto, esse processo se torna longo e complicado à medida que o programa fica mais complexo. Uma maneira de evitar o problema é o desenvolvimento Orientado a Testes.

É uma técnica extremamente prática, para agilizar o desenvolvimento e facilitar a manutenção do código. Basicamente, ele funciona assim:

1.      Escreva um teste para uma determinada funcionalidade. Ele deve falhar inicialmente, pois o código testado não foi criado;

2.      Escreva apenas a funcionalidade necessária para passar no teste, da maneira mais simples possível;

3.      Reveja o teste e o código para melhorar a implementação da funcionalidade e melhorar a legibilidade, eliminando testes duplicados;

4.      Volte ao passo 1;

5.      Repita até que não haja mais nada a testar.

Esse processo é conhecido como Red/Green/Refactor, pois inicialmente o teste falha (Red), em seguida ele passa (Green) e, finalmente você revê o código e melhora-o (Refactor), repetindo até que o processo se esgote e não haja mais nada a adicionar.

Como podemos ver, essa metodologia é bem simples e resulta num código limpo e bem objetivo, evitando ao máximo os bugs e falhas no processo.

 

Vantagens da Orientação a Testes

Desenvolver com a metodologia de testes traz várias vantagens, entre elas:

·         O código sempre é focado no objetivo (completar o teste), de maneira que o desenvolvimento fica mais rápido e direto;

·         Os testes são acumulados, formando um conjunto de testes que é sempre executado, possibilitando assim encontrar pequenos erros que aparecem conforme o código aumenta;

·         Se os testes são bem feitos, há uma garantia de que o código satisfaz os requisitos necessários, pois sabemos exatamente se o código passa ou não no teste; também podemos verificar se os requisitos do cliente batem com os que o desenvolvedor colocou em seus testes;

·         Devido ao refactoring em todas as etapas, o código resultante será extremamente legível e fácil de manter;

·         Os testes documentam o código: o teste deve ser tal que, olhando o teste, você saiba exatamente o que o código correspondente faz;

·         Você pode medir o progresso do desenvolvimento através dos testes. Se o programa passa todos os testes numa determinada fase do desenvolvimento, você pode dizer com certeza que o código preenche os requisitos de todos os testes feitos.

Portanto, é extremamente útil orientar o seu desenvolvimento a testes (aliados ao refactoring). Mas como fazer isso?

 

Técnicas de desenvolvimento com testes usando o NUnit

Para ilustrar essa metodologia, utilizaremos uma ferramenta gratuita chamada NUnit. Ela serve para automatizar os testes no ambiente .NET e se integra facilmente ao Visual Studio 2005 (incluindo versões Express).

Primeiramente, baixe a versão adequada (www.nunit.org/index.php?p=download) e instale o NUnit no seu ambiente de desenvolvimento. Ao abrir o NUnit, você verá uma tela como a Figura 1.

 

image002.jpg

Figura 1. Tela principal do NUnit

 

Para se familiarizar com o ambiente, você pode executar os testes de uma DLL que vem com o NUnit, a nunit-gui.tests.dll, que pode ser encontrada na pasta de instalação, no subdiretório bin. Ao carregá-la e clicar no botão Run (Executar), você verá que os testes serão executados, e todos passarão (ficarão verdes), conforme vemos na Figura 1.

Esse sistema de cores é para facilitar a visualização do resultado e lembra um semáforo: verde significa que o teste passou, amarelo significa que o teste não foi executado (foi ignorado) e vermelho significa falha. Além das cores, a parte da direita da janela mostra detalhes sobre os possíveis erros nos testes.

 

"

A exibição deste artigo foi interrompida :(
Este post está disponível para assinantes MVP

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?