Tecnologia

Tutorial, ou melhor, um passo-a-passo explicando o funcionamento do Junit

Por: , setembro 25, 2013


Pagina oficial:  http://junit.org/
Git:  https://github.com/junit-team/junit
Junit é um framework simples para escrever testes repetíveis automatizados com suporte na linguagem de programação Java. Com o Junit podemos criar testes para verificar funcionalidades de classes e seus métodos. Podemos automatizar também a execução de todos os testes de forma que quando for criada uma nova versão estável do sistema o framework execute todos os testes para garantir a integridade e estabilidade do sistema desenvolvido.

O Junit tem uma extrema importância no desenvolvimento de métodos ágeis de programação como o TDD (Test Driven Development) que consiste em escrever o teste antes e depois desenvolver a funcionalidade. Para ler mais sobre TDD acesse:  http://pt.wikipedia.org/wiki/Test_Driven_Development
 
Para utilizar o Junit em seu projeto basta realizar a configuração no maven. A seguir temos a configuração:  https://github.com/junit-team/junit/wiki/Use-with-Maven
O Junit trabalha basicamente com anotações (Annotations). Essas anotações indicam se um método é de teste ou não, se um método deve ser executado antes da classe e/ou depois da classe, as anotações indicam também se o teste deve ou não ser ignorado e se a classe em questão é uma suite de teste, ou seja, se a partir desta classe é disparada a execução das demais classes de teste, entre outras anotações menos utilizadas.

ANOTAÇÕES

Para determinar se um método é de teste utilizamos logo acima da classe de teste a anotação: * @Test
Exemplo:

@Test
public void testName() {
}

Para ignorar um método de teste utilizamos a anotação:

  • @Ignore

Exemplo:

@Ignore
@Test
public void testName() {
}

Para determinar que um método vai ser executado antes dos demais métodos da classe de teste utilizamos a anotação:

  • @BeforeClass.

Essa funcionalidade serve para que possamos antes de uma classe de teste por exemplo iniciar a conexão com o banco de dados, inicializar variaveis entre outras possibilidades. Exemplo:

@BeforeClass
public void setup() {
    dataBase = new DataBase();
   dataBaseConnection.open();
   dataBase.populate();
   list_name = new ArrayList<>();
   index = 0;
}

Para determinar que um método vai ser executado depois dos demais métodos da classe de teste utilizamos a anotação:

  • @AfterClass.

Essa funcionalidade serve para que possamos depois de uma classe de teste por exemplo fechar a conexão com o banco de dados, ajudar o garbage collection a limpar os dados ociosos entre outras possibilidades.

Exemplo:

@AfterClass
public void close() {
    dataBase.drop();
    dataBaseConnection.close();
    dataBase = null;
    list_name = null;
    index = null;
}

Para determinar que um método vai ser executado antes de cada caso de teste utilizamos a anotação:

  • @Before.

Essa funcionalidade serve por exemplo para que antes de um método possamos inicializar variaveis. Exemplo:

@Before
public void initialize() {
    list_name = new Calendar.getAllNames();
    index = 55;
}

Para determinar que um método vai ser executado depois de cada caso de teste utilizamos a anotação:

  • @After.

Essa funcionalidade serve por exemplo para que antes de um método possamos finalizar variaveis. Exemplo:

@After
public void finalize() {
    list_name = calendar.getAllNames();
    index = current_index;
}

Com a última versão do Junit podemos também determinar que um teste tem um tempo máximo para ser executado. Por exemplo caso desejamos que nosso teste não demore mais que 500 milisegundos podemos realizar a seguinte anotação:

@Test(timeout = 500)
public void fastTestCase() {
    Assert.assertEquals(1500, calendar.getSize());
}

Por fim em nossa última anotação temos uma das mais importântes para testes unitários. Nesta anotação podemos verificar se o método está retornando uma exception. Essa funcionalidade é muito importante por exemplo para sabermos se o sistema está realmente tratando exceções e/ou validando erros internos. Exemplo:

@Test(expected=NullPointerException.class)
public void testException(int input) {
    int month = 4;
    Assert.assertNotNull(calendar.getAllDays(month));
}

 
Os asserts determinam se uma condição de teste foi atendida ou não. Para ver os tipos de asserts bem como suas utilizações acesse:  https://github.com/junit-team/junit/wiki/Assertions



 
Uma outra ferramenta importante é a criação de uma suite de testes, que nada mais é do que uma classe java onde todos os testes são iniciados. Nessa suite são descritas as classes de teste ou padrão das classes de teste para a sua execução. Uma suite de teste é basicamente uma classe que vai disparar a execução das demais classes de teste.
Abaixo exemplo de uma classe de suite de teste onde são descritos os testes a serem executados:

import org.junit.runner.RunWith;
import org.junit.runners.Suite;
@RunWith(Suite.class)
@Suite.Suite({
  TestLogin.class,
  TestLogout.class,
  TestCalendarNavigate.class,
  TestCalendarUpdate.class
})
public class CalendarTestSuite {
}

Na anotação RunWith indica a suite de teste e na segunda anotação @Suite.Suite é onde indicamos as classes de teste que serão executadas. Neste caso acima as classes TestLogin.class, TestLogout.class, TestCalendarNavigate.class e TestCalendarUpdate.class.
Entretanto há outra forma de disparar a execução de todos os testes. Com a anotação @ClassnameFilters definimos os padrões das classes de teste. Todas as classes de teste que atendem a esses padrões serão executadas.
Abaixo temos o exemplo de uma classe de suite de teste onde definimos os padrões das classes de teste. Dessa forma todas as classes de teste que estiverem no padrão citado serão executadas.

import javax.naming.NamingException;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.extensions.cpsuite.ClasspathSuite;
import org.junit.extensions.cpsuite.ClasspathSuite.ClassnameFilters;
import org.junit.runner.RunWith;
@RunWith(Suite.class)
@ClassnameFilters({ ".*Test", ".*Teste" })
public class SuiteTest {
   @BeforeClass
    public static void setup() {
    }
    @AfterClass
    public static void close() {
    }
}

Como está descrito acima então com a anotação “@ClassnameFilters({ “.*Test”, “.*Teste” })” as classes de teste contendo em seus nomes “Test” e “Teste” serão executadas automaticamente.

  • Receba nosso conteúdo em primeira mão.