JUnit ErrorCollector @Rule com exemplo

Em um cenário normal, sempre que você identificar algum erro durante a execução do teste, você interromperá o teste, corrigirá o erro e executará novamente o teste.

BUT JUnit tem uma abordagem um pouco diferente. Com JUnit coletor de erros, você ainda poderá continuar com a execução do teste mesmo depois que um problema for encontrado ou o teste falhar. O coletor de erros coleta todos os objetos de erro e os relata apenas uma vez após o término da execução do teste.

Por que usar o Coletor de Erros?

Ao escrever um script de teste, você deseja executar todos os testes mesmo se alguma linha de código falhar devido a falha de rede, falha de asserção ou qualquer outro motivo. Nessa situação, você ainda pode continuar executando o script de teste usando um recurso especial fornecido por JUnit conhecido como “coletor de erros”.

Por esta, JUnit utiliza Anotação @Rule que é usado para criar um objeto de coletor de erros. Depois que o objeto para coletor de erros for criado, você poderá adicionar facilmente todos os erros ao objeto usando o método addError (erro lançável). Como você sabe, isso Lançável é a superclasse de Exceção e erro aula em Java. Quando você adiciona erros desta forma, esses erros serão registrados JUnit resultado do teste .

A vantagem de adicionar todos os erros em um Coletor de Erros é que você pode verificar todos os erros de uma só vez. Além disso, se o script falhar no meio, ele ainda poderá continuar executando-o

Observação: No caso de usar assert simples ou bloco try/catch, usar o método coletor de erros não será possível.

Código de amostra

Para entender melhor o coletor de erros, veja o exemplo de código abaixo, que demonstra como criar um objeto coletor de erros e adicionar todos os erros desse objeto à lista de erros. traco problema:

package guru99.junit;		

import org.junit.Rule;		
import org.junit.Test;		
import org.junit.rules.ErrorCollector;		

public class ErrorCollectorExample {				
    @Rule		
    public ErrorCollector collector = new ErrorCollector();							

    @Test		
    public void example() {					
    collector.addError(new Throwable("There is an error in first line"));							
    collector.addError(new Throwable("There is an error in second line"));							
    collector.checkThat(getResults(),			
                not(containsString("here is an error")));			
    // all lines of code will execute and at the end a combined failure will		
    be logged in.		
    }		
}	

O que é @Rule em jUnit?

JUnit fornece um tipo especial de tratamento de testes, Caso de teste ou conjunto de testes usando anotação @rule. Usando @rule, você pode adicionar ou redefinir facilmente o comportamento do teste.

Existem várias regras internas fornecidas por JUnit API que um testador pode usar, ou até mesmo você pode escrever nossa própria regra.

Veja a linha de código abaixo, que mostra como usar a anotação @rule junto com o Error Collector:

@Rule				
public ErrorCollector collector= new ErrorCollector();

Exemplo usando ErrorCollector

Para entender o coletor de erros, vamos criar uma classe e uma regra para coletar todos os erros. Você adicionará todos os erros usando addError(throwable) aqui.

Veja o código abaixo que simplesmente cria uma regra que nada mais é do que criar um “objeto Coletor de Erros”. Que é ainda usado para adicionar todos os erros a fim de relatar o problema no final:

ErrorCollectorExample.java

package guru99.junit;		

import org.junit.Assert;		
import org.junit.Rule;		
import org.junit.Test;		
import org.junit.rules.ErrorCollector;		

public class ErrorCollectorExample {				
    @Rule		
    public ErrorCollector collector = new ErrorCollector();							

    @Test		
    public void example() {					
    collector.addError(new Throwable("There is an error in first line"));							
    collector.addError(new Throwable("There is an error in second line"));							

        System.out.println("Hello");					
        try {			
            Assert.assertTrue("A " == "B");					
        } catch (Throwable t) {					
            collector.addError(t);					
        }		
        System.out.println("World!!!!");					
    }		
}		

TestRunner.java

Vamos adicionar a classe de teste acima em um executor de teste e executá-la para coletar todos os erros. Veja 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) {									
      Result result = JUnitCore.runClasses(ErrorCollectorExample.class);					
			for (Failure failure : result.getFailures()) {							
         System.out.println(failure.toString());					
      }		
      System.out.println("Result=="+result.wasSuccessful());							
   }		
}      

Saída:

Veja a falha trace qual tracreúne todos os erros em um só lugar:

Benefícios da JUnit Coletor de erros

Você pode usar JUnit afirmação para validação funcional ou GUI, por exemplo

1. assertEquals(String mensagem, Objeto esperado, Objeto real) que compara que dois objetos são iguais.
2. Da mesma forma, assertTrue(Boolean Condition) afirma que uma condição é verdadeira.

Usando asserção, o teste de validação torna-se fácil. Mas uma questão importante é que a execução do teste será interrompida mesmo se uma única asserção falhar.

A continuidade dos testes e o tratamento da recuperação são cruciais para o sucesso da automação de testes. Error Collector é a melhor maneira de lidar com esse tipo de cenário.

Resumo

• O coletor de erros Junit permite que um teste continue mesmo depois que o primeiro problema for encontrado e o teste falhar no final
• O coletor de erros coleta todos os objetos de erro e reporta apenas, afinal, a execução do teste acabou
• A vantagem de adicionar todos os erros em um Coletor de Erros é que você pode verificar todos os erros de uma vez
• O coletor de erros simplesmente adiciona erros usando o método addError(throwable err) fornecido por ErrorCollector.java.