Melhorando os testes escritos com JUnit

O artigo Escrevendo testes de unidade com JUnit descreveu a maneira mais simples de se escrever testes unitários. Nesse artigo serão abordados, complementando a implementação do artigo anterior, mecanismos para checagem de exceções e a introdução de pré/pós condições ao teste ou cenário de testes.

Prés e Pós Condições

Através das anotações @Before, @BeforeClass, @After e @AfterClass é possível configurar os cenários comuns de acordo com as necessidades dos testes ou conjunto de testes.

Os métodos anotados com @Before e @After são executados anterior e posteriormente à cada método anotado com @Test. De maneira semelhante funcionam as anotações @BeforeClass e @AfterClass. O cenário mais comum para o uso dessas anotações é a realização de configurações comuns aos testes, como abertura e fechamento de arquivos ou conexões.

Para exemplificar, nosso teste foi atualizado para que a instância utilizada em todos os casos seja a mesma, inicializada utilizando o método anotado com @BeforeClass:

[java]
private static DilemaDoPrisioneiro dp;

@BeforeClass
public static void init() {
dp = new DilemaDoPrisioneiro();
}[/java]

Listagem 1 – Exemplificando o uso de @BeforeClass

Além disso, foi adicionado um teste para verificar a correta inicialização da instância utilizada:

[java]
@Test
public void testInit() {
Assert.assertNotNull(dp);
}[/java]

Listagem 2 – Teste criado com variável inicializada no @BeforeClass

Exceções

Qualquer método pode lançar uma exceção e isso também pode ser checado durante os testes unitários, basta adicionar o atributo expected na anotação @Test e configurar com a classe da exceção esperada:

[java]@Test(expected = Exception.class)
public void testException() throws Exception {
throw new Exception(“Exception de teste”);
}[/java]

Listagem 3 – Exemplo de teste verificando a ocorrência de uma Exception

A implementação da classe DilemaDoPrisioneiro foi alterada pra lançar uma exceção caso uma das respostas não seja informada:

[java]public int calculaPena(Resposta respostaSuspeitoA, Resposta respostaSuspeitoB) throws DilemaDoPrisioneiroException {

if (respostaSuspeitoA == null) {
throw new DilemaDoPrisioneiroException(“Resposta do Suspeito A não informada”);
}

if (respostaSuspeitoB == null) {
throw new DilemaDoPrisioneiroException(“Resposta do Suspeito B não informada”);
}

// …

}[/java]

Listagem 4 – Código atualizado para lançar uma Exception

O teste que trata esse caso é o seguinte:

[java]
@Test(expected = DilemaDoPrisioneiroException.class)
public void testRespostaSuspeitoANaoInformada() throws Exception {
dp.calculaPena(null, Resposta.DELACAO);
}[/java]

Listagem 5 – Teste atualizado com o tratamento da Exception

Conclusão

Apenas utilizando os recursos existentes no JUnit é possível criar cenários de testes cada vez mais complexos, mas ainda simples o suficiente para não se tornarem custosos demais em termos de implementação e execução.

Links Externos

Por MARCO ANTONIO ROCHA

Pai, marido, nerd e programador (não necessariamente nessa ordem). Analista de Sistemas ancorado na MATERA desde 2008. Desenvolvedor Java na maior parte do tempo, fuçador em tempo integral.

Postado em: 09 de janeiro de 2014

Confira outros artigos do nosso blog

[Webinar] Profile de aplicações Java com Oracle Mission Control e Flight Recorder

24 de julho de 2017

Danival Calegari

Criando Mocks de serviços REST com SoapUI

27 de junho de 2017

Monise Costa

Three laws that enable agile software development

09 de março de 2017

Celso Gonçalves Junior

Medindo performance de uma API REST

21 de fevereiro de 2017

Monise Costa

Deixe seu comentário