JUnit é a estrutura de teste de unidade mais popular em Java. É explicitamente recomendado para testes de unidade. O JUnit não requer servidor para testar o aplicativo da web, o que torna o processo de teste rápido.
A estrutura JUnit também permite a geração rápida e fácil de casos de teste e dados de teste. O pacote org.Junit consiste em muitas interfaces e classes para testes JUnit, como Test, Assert, After, Before, etc.
O que é dispositivo de teste
Antes de entendermos o que é uma fixação de teste, vamos estudar o código abaixo
Este código é projetado para executar dois casos de teste em um arquivo simples.
public class OutputFileTest {Saída de arquivo privada;saída = novo arquivo (…);output.delete ();public void testFile1 () {// Código para verificar o caso de teste 1}output.delete ();saída = novo arquivo (…);public void testFile2 () {// Código para verificar o caso de teste 2}output.delete ();}
Alguns problemas aqui
- O código não é legível
- O código não é fácil de manter.
- Quando o conjunto de testes é complexo, o código pode conter problemas lógicos.
Compare o mesmo código usando JUnit
public class OutputFileTest{Saída de arquivo privada;@Before public void createOutputFile (){saída = novo arquivo (…);}@After public void deleteOutputFile (){output.delete ();}@Test public void testFile1 (){// código para o objetivo do caso de teste}@Test public void testFile2 (){// código para o objetivo do caso de teste}}
O código é muito mais legível e sustentável. A estrutura de código acima é um dispositivo de teste.
Uma fixação de teste é um contexto onde um Caso de Teste é executado. Normalmente, os acessórios de teste incluem:
- Objetos ou recursos disponíveis para qualquer caso de teste.
- Atividades necessárias que disponibilizam esses objetos / recursos.
- Essas atividades são
- alocação ( configuração )
- desalocação ( desmontagem ).
Configuração e desmontagem
- Normalmente, existem algumas tarefas repetidas que devem ser feitas antes de cada caso de teste. Exemplo: crie uma conexão de banco de dados.
- Da mesma forma, ao final de cada caso de teste, pode haver algumas tarefas repetidas. Exemplo: para limpar quando a execução do teste terminar.
- JUnit fornece anotações que ajudam na configuração e desmontagem. Isso garante que os recursos sejam liberados e o sistema de teste esteja em um estado pronto para o próximo caso de teste.
Essas anotações são discutidas abaixo-
Configurar
A anotação @Before é usada em um método contendo código Java para ser executado antes de cada caso de teste. ou seja, ele é executado antes de cada execução de teste.
Desmontagem (independentemente do veredicto)
A anotação @After é usada em um método contendo código java para ser executado após cada caso de teste. Esses métodos serão executados mesmo se quaisquer exceções forem lançadas no caso de teste ou no caso de falhas de asserção.
Observação:
- É permitido ter qualquer número de anotações listadas acima.
- Todos os métodos anotados com @Before serão executados antes de cada caso de teste, mas podem ser executados em qualquer ordem.
- Você pode herdar os métodos @Before e @After de uma superclasse. Execution é o seguinte: É um processo de execução padrão em JUnit.
- Execute os métodos @Before na superclasse
- Execute os métodos @Before nesta classe
- Execute um método @Test nesta classe
- Execute os métodos @After nesta classe
- Execute os métodos @After na superclasse
Exemplo: Criação de uma classe com arquivo como uma fixação de teste
public class OutputFileTest{Saída de arquivo privada;@Before public void createOutputFile (){saída = novo arquivo (…);}@After public void deleteOutputFile (){output.delete ();}@Test public void testFile1 (){// código para o objetivo do caso de teste}@Test public void testFile2 (){// código para o objetivo do caso de teste}}
No exemplo acima, a cadeia de execução será a seguinte-
- createOutputFile ()
- testFile1 ()
- deleteOutputFile ()
- createOutputFile ()
- testFile2 ()
- deleteOutputFile ()
Suposição: testFile1 () é executado antes de testFile2 () - o que não é garantido.
Configuração única
- É possível executar um método apenas uma vez para toda a classe de teste antes de qualquer um dos testes ser executado e antes de qualquer método @Before .
- "Uma vez apenas a configuração" é útil para iniciar servidores, abrir comunicações, etc. É demorado fechar e reabrir recursos para cada teste.
- Isso pode ser feito usando a anotação @BeforeClass
@BeforeClass public static void Method_Name () {// código de configuração da classe aqui}
Derrubar uma vez
- Semelhante à configuração única, um método de limpeza única também está disponível. Ele é executado após todos os métodos de caso de teste e anotações @After terem sido executados.
- É útil para parar servidores, fechar links de comunicação, etc.
- Isso pode ser feito usando a anotação @AfterClass
@AfterClass public static void Method_Name (){// código de limpeza de classe aqui}
JUnit Test Suites
Se quisermos executar vários testes em uma ordem especificada, isso pode ser feito combinando todos os testes em um só lugar. Este local é chamado de suítes de teste. Mais detalhes sobre como executar suites de teste e como ele é usado no JUnit serão abordados neste tutorial.
Corredor de teste Junit
JUnit fornece uma ferramenta para execução de seus casos de teste.
- A classe JUnitCore é usada para executar esses testes.
- Um método chamado runClasses fornecido por org.junit.runner.JUnitCore, é usado para executar uma ou várias classes de teste.
- O tipo de retorno deste método é o objeto Result ( org.junit.runner.Result ), que é usado para acessar informações sobre os testes. Consulte o exemplo de código a seguir para obter mais clareza.
public class Test {public static void main (String [] args) {Resultado do resultado = JUnitCore.runClasses (CreateAndSetName.class);para (falha falha: result.getFailures ()) {System.out.println (failure.toString ());}System.out.println (result.wasSuccessful ());}}
No código acima, o objeto "resultado" é processado para obter falhas e resultados bem-sucedidos dos casos de teste que estamos executando.
Primeiro programa JUnit
O conhecimento razoável de SDLC, programação java e noções básicas do processo de teste de software ajuda a entender o programa JUnit.
Vamos entender o teste de unidade usando um exemplo ao vivo. Precisamos criar uma classe de teste com um método de teste anotado com @Test conforme fornecido abaixo:
MyFirstClassTest.java
package guru99.JUnit;import static org.JUnit.Assert. *;import org.JUnit.Test;public class MyFirstClassTest {@Testepublic void myFirstMethod () {String str = "JUnit está funcionando bem";assertEquals ("JUnit está funcionando bem", str);}}
TestRunner.java
Para executar nosso método de teste (acima), precisamos criar um executor de teste. No executor de teste, temos que adicionar a classe de teste como um parâmetro no método runclasses () de JUnitCore. Ele retornará o resultado do teste, com base em se o teste foi aprovado ou reprovado.
Para obter mais detalhes sobre isso, consulte o código abaixo:
package guru99.JUnit;import org.JUnit.runner.JUnitCore;import org.JUnit.runner.Result;import org.JUnit.runner.notification.Failure;public class TestRunner {public static void main (String [] args) {Resultado do resultado = JUnitCore.runClasses (MyFirstClassTest.class);para (falha falha: result.getFailures ()) {System.out.println (failure.toString ());}System.out.println ("Result ==" + result.wasSuccessful ());}}
Resultado
Depois que TestRunner.java executa nossos métodos de teste, obtemos a saída como falha ou aprovada. Encontre a explicação de saída abaixo:
- Neste exemplo, depois de executar MyFirstClassTest.java , o teste é aprovado e o resultado fica verde.
- Se tivesse falhado, deveria ter mostrado o resultado em vermelho e a falha pode ser observada no rastreamento de falha. Veja abaixo JUnit gui:
Resumo :
- JUnit é uma estrutura que suporta várias anotações para identificar um método que contém um teste.
- O JUnit fornece uma anotação chamada @Test, que informa ao JUnit que o método void público no qual é usado pode ser executado como um caso de teste.
- Uma fixação de teste é um contexto onde um caso de teste é executado
- Para executar vários testes em uma ordem especificada, isso pode ser feito combinando todos os testes em um só lugar. Este local é chamado de suítes de teste.
- JUnit fornece uma ferramenta para execução de testes onde podemos executar nossos casos de teste referidos como Test Runner.