O Teste Unitário serve para garantir que o código está funcionando de acordo com as expectativas.Geralmente testes unitários são criados em seu próprio projeto ou tem a sua pasta própria separada do source, para evitar que o código normal e o código de teste fiquem confusos.
Figura 1. Organização dos Pacotes
Instalando
o Framework
Caso você não tenha o JUnit instalado, você deverá
baixar a biblioteca do JUnit. Para utilizar o framework, você precisará colocar o arquivo junit.jar
no classpath do seu ambiente de desenvolvimento preferido. Ele pode ser obtido
fazendo-se o download do arquivo aqui. Em seguida adicione o arquivo junit.jar à biblioteca do seu projeto Java e adicione-o ao classpath.
Porém o JUnit já vem configurado nas versões recentes de IDE’s como Eclipse, NetBeans, JBuilder, BlueJ e outros.
Funcionamento
Para
executar o teste no Eclipse, você deve escolher a opção Run →
Run As →
JUnit Test. Você também pode usar o atalho apresentado
na Figura 2.
Figura
2. Ativando o JUnit no Eclipse.
Quando o
teste funcionar, o JUnit irá apresentar uma barra verde indicando que tudo
correu bem.
Figura 3. Barra verde do JUnit.
Se algum teste falhar será exibido uma barra vermelha e em Failure Trace será apresentado o motivo da falha.
Figura
4. Barra vermelha no JUnit.
Por padrão
ele mostra todos os testes, mas você pode configurar isto. Clicando em Show Failures Only, serão apresentados apenas os testes que obtiveram falhas.
Figura 5. Visão dos Testes
Você também pode definir
que a visão só é ativada caso exista algum teste com erro.
Figura
6. Visão dos Testes
OBS: O Eclipse cria configurações de
execução de testes. Você pode ver e modificar estes através do menu: Run →Run
Configurations …
Criando
Testes Unitários
O framework JUnit possui várias annotation que são utilizadas para guiar a execução dos testes.Annotations são metadados que possuem algumas configurações específicas. Em seguida serão apresentadas algumas delas:
@Test
Um método de testes é
identificado pela annotation @Test. Obrigatoriamente todos os teste devem conter essa annotation.
.png)
Figura
7.
Declarando um Teste no Junit.
É necessário importar o
pacote import
org.junit.Test;
@Before, @After
Os métodos
de testes podem ser precedidos e sucedidos de outros métodos, portanto se você
quer que algo seja executado antes de cada método de teste “anote-o” com
@Before, e para ser executado após o método de testes use @After.
.png)
Figura 8. Testes com anotação @Before e @After
Você deverá
importar também esses pacotes:
import org.junit.After;
import org.junit.Before;
import org.junit.Before;
Também existem as anotação @BeforeClass e @AfterClass, elas identificam um método static que será executado uma única vez por instância da classe que contém os testes e antes da execução de qualquer método de teste.
Figura 9. Testes com anotação @BeforeClass e
@AfterClass
Assert
O JUnit usa
o termo “assert” pra fazer comparações, para testar certas condições, permitem
que você especifique a mensagem de erro, o resultado esperado e o real.
Afirmação
|
Descrição
|
fail
(String)
|
Deixe
o método falhar.Pode ser usado para verificar se uma determinada parte do
código não é atingido.Ou ter um teste de falha antes do código de teste é
implementado.
|
assertTrue([message],
boolean condition)
|
Verifica
se a condição booleana é verdadeira.
|
assertsEquals([String message], expected, actual)
|
Testa se os dois valores são os mesmos. Nota: para matrizes de referência não é
verificado o conteúdo das matrizes.
|
assertsEquals([String message], expected, actual,
tolerance)
|
Testa se os valores float ou double correspondem. A tolerância é o número de casas decimais
que devem ser o mesmo.
|
assertNull
([mensagem], objeto)
|
Verifica
se o objeto é nulo.
|
assertNotNull
([mensagem], objeto)
|
Verifica
se o objeto não é nulo.
|
assertSame
([String], esperado, real)
|
Verifica
se as duas variáveis se referem ao mesmo objeto.
|
assertNotSame
([String], esperado, real)
|
Verifica
se as duas variáveis se referem a objetos diferentes.
|
Melhorando o feedback das falhas
nos testes
O
JUnit permite especificar uma mensagem a ser exibida quando ocorre uma falha,
para facilitar a depuração. No caso do assertFalse(),
por exemplo, existem duas sobrecargas:
Figura 10. Variações do método assertFalse()
Isso também ocorre com o método assertEquals().
Figura 11. Variações do método assertEquals()
Figura 12. Teste com mensagem de erro
Tratamento de Exceções
Utilize o parâmetro
“expected” da annotation @Test para casos de uso que esperam exceptions.
Escreva o nome da classe da Exception que deverá ser lançada.
Se a exceção não for
levantada ou ainda que levantada não seja a esperada o teste é tido como falho.
.png)
Figura 13. Teste que espera uma exceção.
@Ignore
Use a annotation
@Ignore para testes que você queira ignorar. Você pode adicionar um parâmetro
String que defina o motivo pelo qual você está ignorando o teste.
Assim não é preciso excluir ou comentar o código dos testes ignorados.
.png)
Figura 14. Teste ignorado.
Timeout
O parâmetro “timeout”
define o tempo máximo em milisegundos. O teste falha caso o período seja
excedido. Esta anotação auxilia testes que contenham dentro de sua estrutura
instruções bloqueantes como comandos de socket e acesso a banco de dados, por
exemplo.
.png)
Figura 15. Teste com tempo de execução
definido.
Por hoje é só, pessoal. Espero que tenham gostado do nosso pequeno e breve artigo. Qualquer dúvida e/ou sugestão é só entrar em contato.
Até mais.
Bibliografia
<http://www.vogella.com/articles/JUnit/article.html Acessado em 12/04/2013>
<http://rodrigomaia.net/tag/junit4/
Acessado em 12/04/2013>
<http://www.futurepages.org/wiki/doku.php?id=quickstart:testes_com_junit_4 Acessado em 12/04/2013>
<http://www.futurepages.org/wiki/doku.php?id=quickstart:testes_com_junit_4 Acessado em 12/04/2013>
<http://blog.andrefaria.com/junit-4-em-60-segundos
Acessado em 12/04/2013>
<http://www.devmedia.com.br/criando-testes-de-unidades-com-o-junit-4-usando-anotacoes/4798 Acessado em 12/04/2013>
<http://www.improveit.com.br/xp/praticas/tdd Acessado em 12/04/2013>
Nenhum comentário:
Postar um comentário