JUnit ErrorCollector @Rule avec exemple
Thomas Hamilton
Dans un scénario normal, chaque fois que vous identifiez une erreur lors de l'exécution du test, vous arrêtez le test, corrigez l'erreur et réexécutez le test.
Mais JUnit a une approche légèrement différente. Avec JUnit collecteur d'erreurs, vous pouvez toujours poursuivre l'exécution du test même après la détection d'un problème ou l'échec du test. Le collecteur d'erreurs collecte tous les objets d'erreur et ne les signale qu'une seule fois après la fin de l'exécution du test.
Pourquoi utiliser le collecteur d'erreurs ?
Lors de l'écriture d'un script de test, vous souhaitez exécuter tous les tests même si une ligne de code échoue en raison d'une défaillance du réseau, d'un échec d'assertion ou de toute autre raison. Dans cette situation, vous pouvez toujours continuer à exécuter le script de test en utilisant une fonctionnalité spéciale fournie par JUnit connu sous le nom de « collecteur d’erreurs ».
Pour ça, JUnit Usages @Règle annotée qui est utilisé pour créer un objet de collecteur d'erreurs. Une fois l'objet du collecteur d'erreurs créé, vous pouvez facilement ajouter toutes les erreurs dans l'objet à l'aide de la méthode addError (Erreur pouvant être lancée). Comme vous le savez, ce Jetable est la super classe de Exception et Erreur classe dans Java. Lorsque vous ajoutez des erreurs de cette manière, ces erreurs seront enregistrées JUnit résultat du test .
L'avantage d'ajouter toutes les erreurs dans un collecteur d'erreurs est que vous pouvez vérifier toutes les erreurs en même temps. De plus, si le script échoue au milieu, il peut toujours continuer à l'exécuter.
Note: Dans le cas de l'utilisation d'un simple bloc assert ou try/catch, l'utilisation de la méthode du collecteur d'erreurs ne sera pas possible.
Exemple de code
Pour en savoir plus sur Error Collector, voir l'exemple de code ci-dessous qui montre comment créer un objet Error Collector et ajouter toutes les erreurs dans cet objet pour suivre le problème :
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.
}
}
Qu’est-ce que @Rule dans jUnit ?
JUnit fournit un type spécial de traitement des tests, Cas de test ou une suite de tests en utilisant @ruleannotation. En utilisant @rule, vous pouvez facilement ajouter ou redéfinir le comportement du test.
Il existe plusieurs règles intégrées fournies par JUnit API qu'un testeur peut utiliser, ou même vous pouvez écrire notre propre règle.
Voir la ligne de code ci-dessous, qui montre comment utiliser l'annotation @rule avec Error Collector :
@Rule public ErrorCollector collector= new ErrorCollector();
Exemple utilisant ErrorCollector
Pour comprendre le collecteur d'erreurs, créons une classe et une règle pour collecter toutes les erreurs. Vous ajouterez toutes les erreurs en utilisant addError(throwable) ici.
Voir le code ci-dessous qui crée simplement une règle qui n'est rien d'autre que la création d'un « objet Collecteur d'erreurs ». Qui est ensuite utilisé pour ajouter toutes les erreurs afin de signaler le problème à la fin :
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
Ajoutons la classe de test ci-dessus dans un exécuteur de test et exécutons-la pour collecter toutes les erreurs. Voir le code ci-dessous :
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());
}
}
Sortie :
Consultez la trace des échecs qui retrace toutes les erreurs en un seul endroit :
Bénéfices du JUnit Collecteur d'erreurs
Vous pouvez utiliser JUnit assertion pour la validation fonctionnelle ou graphique, par exemple
- assertEquals (message de chaîne, objet attendu, objet réel) qui compare le fait que deux objets sont égaux.
- De même, assertTrue(Boolean condition) affirme qu'une condition est vraie.
Grâce à l'assertion, le test de validation devient facile. Mais un problème majeur est que l’exécution des tests s’arrêtera même si une seule assertion échoue.
La continuité des tests et la gestion de la récupération sont cruciales pour le succès de l’automatisation des tests. Error Collector est le meilleur moyen de gérer ce type de scénarios.
Résumé
- Le collecteur d'erreurs Junit permet à un test de continuer même après la détection du premier problème et l'échec du test à la fin
- Le collecteur d'erreurs collecte tous les objets d'erreur et ne les signale qu'après tout l'exécution du test.
- L'avantage d'ajouter toutes les erreurs dans un collecteur d'erreurs est que vous pouvez vérifier toutes les erreurs en même temps.
- Le collecteur d'erreurs ajoute simplement des erreurs à l'aide de la méthode addError (throwable err) fournie par ErrorCollector.java.
