Em um cenário normal, sempre que você identifica algum erro durante a execução do teste, você interrompe o teste, corrige o erro e executa novamente o teste.
Mas JUnit tem uma abordagem ligeiramente diferente. Com o coletor de erros JUnit, você ainda pode 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.
Neste tutorial, você aprenderá-
- O que é coletor de erros no JUnit?
- O que é @Rule no jUnit?
- Exemplo usando ErrorCollector
- Benefícios do JUnit ErrorCollector
Por que usar o Error Collector?
Ao escrever um script de teste, você deseja executar todos os testes, mesmo se qualquer linha de código falhar devido a falha de rede, falha de declaração ou qualquer outro motivo. Nessa situação, você ainda pode continuar executando o script de teste usando um recurso especial fornecido pelo JUnit conhecido como "coletor de erros".
Para isso, o JUnit usa a anotação @Rule que é usada para criar um objeto coletor de erros. Depois que o objeto do coletor de erros é criado, você pode adicionar facilmente todos os erros ao objeto usando o método addError (Erro lançável). Como você sabe, aquele Throwable é a superclasse das classes Exception e Error em Java. Ao adicionar erros dessa forma, esses erros serão registrados no resultado do teste JUnit.
A vantagem de adicionar todos os erros em um Error Collector é que você pode verificar todos os erros de uma vez. Além disso, se o script falhar no meio, ele ainda pode continuar executando-o
Nota : No caso de usar o bloco simples assert ou try / catch, o uso do método de coletor de erro não será possível.
Código de amostra
Para entender mais sobre o Error Collector, veja o exemplo de código abaixo que demonstra como criar um objeto Error Collector e adicionar todos os erros nesse objeto para rastrear o problema:
package guru99.junit;import org.junit.Rule;import org.junit.Test;import org.junit.rules.ErrorCollector;public class ErrorCollectorExample {@Regrapublic ErrorCollector collector = new ErrorCollector ();@Testepublic void example () {collector.addError (new Throwable ("Há um erro na primeira linha"));collector.addError (new Throwable ("Há um erro na segunda linha"));collector.checkThat (getResults (),not (containsString ("aqui está um erro")));// todas as linhas de código serão executadas e, no final, uma falha combinada seráestar logado.}}
O que é @Rule no jUnit?
JUnit fornece um tipo especial de tratamento de testes, Caso de Teste ou suíte de teste usando a anotação @rule . Usando @rule, você pode facilmente adicionar ou redefinir o comportamento do teste.
Existem várias regras integradas fornecidas pela API JUnit 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:
@Regrapublic 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 abaixo o código que simplesmente cria uma regra que nada mais é do que criar um "objeto Error Collector". Que é usado posteriormente 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 {@Regrapublic ErrorCollector collector = new ErrorCollector ();@Testepublic void example () {collector.addError (new Throwable ("Há um erro na primeira linha"));collector.addError (new Throwable ("Há um erro na segunda linha"));System.out.println ("Olá");tentar {Assert.assertTrue ("A" == "B");} catch (Throwable t) {collector.addError (t);}System.out.println ("Mundo !!!!");}}
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) {Resultado do resultado = JUnitCore.runClasses (ErrorCollectorExample.class);para (falha falha: result.getFailures ()) {System.out.println (failure.toString ());}System.out.println ("Result ==" + result.wasSuccessful ());}}
Resultado:
Veja o rastreamento de falha que rastreia todos os erros em um só lugar:
Benefícios do JUnit ErrorCollector
Você pode usar a asserção JUnit para validação funcional ou GUI, por exemplo
- assertEquals (String mensagem, Objeto esperado, Objeto real) que compara que dois objetos são iguais.
- Da mesma forma, assertTrue (condição booleana) afirma que uma condição é verdadeira.
Usando asserção, o teste de validação se torna fácil. Mas um grande problema é que a execução do teste será interrompida mesmo se uma única asserção falhar.
A continuidade do teste e o manuseio da recuperação são cruciais para o sucesso da automação do teste. O 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 após o primeiro problema ser encontrado e o teste falhar no final
- O coletor de erros coleta todos os objetos de erro e os relata apenas, afinal, a execução do teste ao longo
- A vantagem de adicionar todos os erros em um Error Collector é 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.