Testes Unitários com JUnit

JUnit é um framework de testes unitários para a linguagem de programação Java. Criado por Kent Beck e Erich Gamma, o JUnit tem sido largamente utilizado em corporações com o objetivo de ampliar a testabilidade de componentes de Software desenvolvidos em Java.

A principal unidade de desenvolvimento no JUnit é o teste unitário. Ele torna possível o desenvolvimento de testes pelo desenvolvedor para verificar as operações básicas sendo desenvolvidas. Na construção dos testes unitários, existe um custo temporal de investimento a ser dado pelo codificador da funcionalidade (ou unidade funcional, método, etc.). Porém este investimento é diluído no momento em que o sistema começa a se compor de dezenas, milhares ou até dezenas de milhares de classes.

As principais vantagens do JUnit incluem:

• Facilmente integrável com as IDEs Java já existentes (Eclipse, Netbeans, JBuilder, etc.).
• API fácil de usar, composta de métodos de verificação (assertXXX()) e métodos de preparo (setUp() e tearDown()) disponíveis e já implementados e prontos para uso.
• O código de testes pode ser fisicamente separado do código da aplicação, evitando que trechos de testes dentro do código da aplicação possam alterar o comportamento da mesma.
• Gratuito
• Testes específicos (suites) podem ser executados para partes específicas da aplicação.
• A construção de testes nos auxilia na definição das interfaces das classes (métodos públicos), optando em esconder detalhes da implementação de algumas funcionalidades.
• Com a existência dos testes, bugs podem ser encontrados mais rapidamente (apenas uma execução dos testes), especialmente quando ocorrem alterações pelo desenvolvedor ou por terceiros.
• Usado no desenvolvimento vontado para testes (test driven development), onde os testes são codificados antes do código da unidade funcional (método).
• Pode ser usada como métrica de qualidade do software no que diz respeito a requisitos funcionais sendo contemplados na aplicação

Terminologia:

• Test fixture: inicializadores de objetos que serão testados, sempre executado a cada teste unitário. Por exemplo, se o método saque da classe ContaBancaria será testado, este bloco criará um objeto de ContaBancaria que possibilitará o teste do saque.
• Unit test: teste unitário de uma única classe Java. Geralmente cria-se uma classe de teste unitário para cada classe Java e um método de teste para cada método público da classe.
• Test case: caso de teste que é implementado para cada método público da classe
• Test Suite: conjunto de testes
• Test runner: executador dos testes e que também mostra os resultados dos mesmos.

As principais classes do framework JUnit:

Processo de desenvolvimento com testes:

1. O teste é criado para definir algum aspecto do problema a ser testado, este contendo algum código simples para que ele passe.
2. Um segundo teste é criado para cobrir todas as possibilidades possíveis na funcionalidade desenvolvida.
3. Novos testes são criados até que não haja nenhum método público da classe sem testes (cobertura de 100%)

Exemplo de teste:

Dado a classe Java abaixo:

A seguinte classe de testes unitários pode ser escrita:

Executando os testes unitários em uma IDE (nesta caso o Eclipse), o resultado dos testes pode ser acompanhado através da aba JUnit, conforme mostrada abaixo.

Links:

• JUnit Homepage
• JUnit Javadoc API

• MobileJUnit

Como modelar testes unitários para entidades/objetos Java

O primeiro passo na modelagem de testes unitários para entidades/objetos Java é identificar todos os possíveis caminhos que um dado usuário poderá passar pela operação ou funcionalidade implementada. Em geral sempre existirão casos de sucesso (esperado pelo usuário) e casos de falha (fluxo alternativo de execução que acarretará numa exceção). Em alguns casos onde não se espera um erro, apenas os casos de sucesso serão testados pelos testes de unidade.

O importante também é sempre testar as fronteiras (valores bem próximos do limite (dentro e fora) e os valores de limite) para garantir que os limites estejam sendo respeitados corretamente.

Por exemplo:

Classe ContaBancaria

Operações implementadas:

1. depositar:

a) um valor positivo (caso de sucesso) e
b) um valor negativo (caso de falha) como entrada.

2. sacar:

a) o um valor positivo que seja menor que o saldo disponível em conta (caso de sucesso)
b) o um valor positivo que seja iguai ao saldo disponível em conta (caso de sucesso)
c) o um valor positivo que seja maior que o saldo disponivel em conta mas menor que a soma do valor do cheque especial e o saldo disponivel em conta (caso de sucesso)
d) o um valor positivo que seja igual a soma do valor do cheque especial e o saldo disponivel em conta (caso de sucesso)
e) o um valor positivo que seja maior que o saldo disponivel em conta e o cheque especial somados (caso de falha)
f) o um valor negativo (caso de falha)

Para cada um dos casos acima, será necessário a implementação de um teste unitário com a responsabilidade de verificar a corretude da implementação.

Um exemplo de implementação do caso de sucesso para o depósito pode ser feito da seguinte maneira (teste unitário dentro da classe de testes):

/**
* testar deposito
*/
public void testarDeposito(){
double valorDepositar = 500.0;
double valorEsperado = conta.getSaldo() + valorDepositar;
conta.depositar(valorDepositar);
// comparar o saldo na conta

assertEquals(”Saldo está incorreto”, valorEsperado, conta.getSaldo());
}

E um exemplo de um teste unitário de falha para o saque:

/**
* testando o saque com valor alem do disponivel em cheque especial.
*/
public void testarSaqueMaiorQueChequeEspecial(){
double valorSacar = conta.getTipoConta().obterValorChequeEspecial() + 101;
conta.depositar(100);
double valorEsperado = conta.getSaldo();

conta.sacar(valorSacar);

assertEquals(”O valor saldo está incorreto”, valorEsperado, conta.getSaldo());
}

Como executar um teste ou conjunto de testes unitários no Eclipse 3.x

Como executar um teste unitário ou um conjunto de testes unitários:

1- Selecionem na aba Project Explorer (onde está o projeto) o teste ou o conjunto de testes (dentro de um único pacote) que se deseja executar
2- botão direito do mouse, run as, JUnit Test
3- Na mesma área de janela que está o Project Explorer (onde ficam os projetos do Eclipse), haverá uma aba de JUnit, onde mostrará os resultados da execução do teste unitário.

Adicionando uma unidade de teste em um projeto do Eclipse 3.x

Como adicionar uma unidade de teste no projeto BancoJava:

1- Selecione na aba Project Explorer o pacote Java onde o teste deve ser criado (a partir da pasta test)
2- botão direito do mouse, new, JUnit Test Case
3- Selecionem JUnit versão 3 ou 3.8.1, Digitem o nome da classe de teste.

4- Se precisarem de métodos de inicialização e de encerramento dos testes, selecionem o setUp() e o tearDown().

O método setUp() possui a responsabilidade de criar e preparar os objetos relacionados aos testes que serão executados. O método tearDown() é responsável por destruir estes objetos para uma próxima execução de um teste unitário. Para cada teste unitário existente, ambos métodos serão executados na seguinte ordem:

1. o setUp() é executado
2. o teste de unidade é executado
3. o tearDown() é executado
4. os passos 1 a 3 são repetidos até que todos os testes de unidades sejam executados.

5- Cliquem em finish

Adicionando o JUnit em um projeto no Eclipse 3.x

Como adicionar o JUnit no projeto do Eclipse:

1) Acesse o site http://www.junit.org/, link “Download JUnit”
2) Baixem a ultima versão (4.4), arquivo “junit-4.4.jar”
3) No Package Explorer, clique no projeto “BancoJava”, botão direito, properties, Java Build Path, aba Libraries

4.1) Removam a variável JUnit na listagem, para que não haja conflitos entre os dois.
4.2) Clique em “Add External JARs” e selecione o arquivo junit-4.4.jar baixado no passo (2).
5) Clique em OK
6) Vá no menu Project, opção clean (isto fará que o Eclipse recompile o projeto).