Introdução às anotações JUnit
O JUnit é uma das mais poderosas estruturas de teste de código aberto e baseadas em Java disponíveis gratuitamente no mercado. Ajuda na criação fácil e rápida de casos de teste e na execução de casos de teste de acordo com os requisitos com a ajuda de anotações. As anotações basicamente fornecem informações extras sobre as classes e os métodos usados no código Java. Ajuda na execução de testes de cada componente da unidade, sejam métodos, classes, pacotes e variáveis. É comumente usado para teste de unidade de aplicativos. A atualização mais recente do JUnit é JUnit5. Ele suporta o driver da web Selenium para o teste de automação de aplicativos móveis e da web. org. Junit é o pacote que contém todas as interfaces e classes para teste através do JUnit.
Anotação JUnit s com Exemplo
Abaixo estão algumas anotações da JUnit:
1. @Antes
Existem cenários em que alguns casos de teste ou dados de teste precisam ser criados antes da execução do caso de teste real. Nesse caso, @Antes das anotações aparecerem na imagem. A anotação de qualquer método público com esta anotação permite que o código / método seja executado antes de cada método @test real. No caso de herança, os métodos @before da superclasse são chamados primeiro e, em seguida, os métodos @before da classe atual.
2. @Depois
É exatamente o oposto da anotação @Antes. É usado nos casos em que algumas ações precisam ser executadas, como liberação de recursos, limpeza de memória, impressão de qualquer coisa no console após a execução do método @test (após a execução de cada caso de teste). Há um ponto importante que deve ser observado na anotação @After é que ela será executada mesmo no caso em que os métodos @test ou @before gerem uma exceção. No caso do relacionamento entre sub e superclasse, o método @after da subclasse / classe atual é executado antes do método @after da superclasse.
3. @BeforeClass
Essa anotação é usada nos cenários em que algumas ações precisam ser executadas antes da execução de qualquer caso de teste de uma classe específica, como a criação de uma conexão com o banco de dados, a criação de uma entrada em um banco de dados, a entrada nos logs, etc. Quando @BeforeClass A anotação é usada antes de qualquer método, esse método é executado antes de qualquer método de teste em uma classe. Seu funcionamento é semelhante à diferença da anotação @Before, sendo que @Before executa o método antes da execução de todos os métodos @test, enquanto @BeforeClass executa apenas uma vez, ou seja, antes da execução de qualquer método @test em uma Classe.
4. @AfterClass
Todos os recursos alocados no método @BeforeClass precisam ser liberados após a execução de todos os métodos @test da classe atual. Essa desalocação de recursos ou qualquer tarefa importante a ser executada após a execução de toda a classe é feita pelo método @AfterClass. Em termos simples, o método @AfterClass é executado após a execução de todo o método @test da classe atual. É executado apenas uma vez. Os métodos @AfterClass são executados obrigatórios, mesmo que os métodos @BeforeClass gerem uma exceção.
Como o método @After, o funcionamento do método @AfterClass é semelhante, exceto pelo fato de o método @After ser executado após cada método @test da classe, enquanto o método @AfterClass é executado uma vez após a execução de todos os métodos @test de uma classe.
5. @Test
Esta anotação especifica que o método público sob esta anotação faz parte do caso de teste principal que precisa ser executado. O método no @test define o caso de teste como aprovado ou com falha, dependendo de ocorrer alguma exceção / erro ao executá-lo.
Também pode ser usado de 2 maneiras:
- @Test (timeout = 500): aceita o parâmetro como timeout, que aceita os valores em milissegundos. Ele considera o caso de teste com falha quando demora mais que o tempo esperado para executar e passa quando é executado com êxito dentro do prazo especificado.
- @Test (esperado = Exception.class): Há situações em que queremos que alguns métodos gerem uma exceção específica. O caso de teste falhará se o método não lançar nenhuma exceção ou a exceção mencionada acima.
6. @Ignore
Existem situações em que queremos ignorar alguns casos de teste e não queremos executá-los. @Ignore ajuda para o mesmo. Os métodos nas anotações @Ignore não são executados e são ignorados durante a execução do código. Mesmo nos relatórios gerados pelo TestNG, mostra a contagem de casos de teste que são ignorados e o número de casos de teste aprovados.
Exemplo
Vamos dar um exemplo de anotações JUnit
package demo;
import org.junit.*;
public class JUnitAnnotationTest (
// Run once, before any @test method in the class are executed
@BeforeClass
public static void bClass() (
System.out.println("BeforeClass method is called”);
)
// Run once after all the @test methods of the class are executed
@AfterClass
public static void aClass() (
System.out.println("AfterClass method is called");
)
// Run before every @test method of a class is executed
@Before
public void bMethod() (
System.out.println("before method is called");
)
// Run after every @test method of class is executed
@After
public void aMethod() (
System.out.println("after method is called");
)
// Test method which has actual test case
@Test
public void testMethod() (
System.out.println("Test method is called");
)
)
Resultado:
Vantagens das anotações JUnit
Abaixo estão algumas das vantagens das anotações JUnit:
- O JUnit fornece uma maneira fácil de executar os casos de teste de uma maneira específica, de acordo com os requisitos do usuário.
- É fácil executar os vários casos de teste paralelamente usando o JUnit combinando-os em um conjunto de testes.
- As anotações JUnit usadas para automatizar casos de teste no Selenium fornecem um relatório gráfico muito detalhado e interativo ao usuário, o que também é muito amigável.
- JUnit permite passar os parâmetros no método usando uma maneira muito simples.
- A anotação JUnit ajuda a executar uma codificação limpa, que é muito fácil de entender para testadores e programadores.
Conclusão
A explicação acima descreve claramente a importância da estrutura JUnit e a ordem na qual várias anotações da JUnit são invocadas. É muito importante entender as várias anotações antes de usá-las em um programa, para que isso não crie nenhum problema no controle do fluxo de execução.
Artigos recomendados
Este é um guia para anotações JUnit. Aqui discutimos a introdução e as anotações do JUnit com o exemplo, que inclui @ Before, @ After, @ Test e @Ignore etc. Você também pode consultar nossos outros artigos sugeridos para saber mais -
- Teste de Unidade
- Teste da caixa branca
- Arquitetura Selenium
- Equipamento de teste