Dans un scénario normal, chaque fois que vous identifiez une erreur pendant l'exécution du test, vous arrêtez le test, corrigez l'erreur et relancez le test.
Mais JUnit a une approche légèrement différente. Avec le collecteur d'erreurs JUnit, vous pouvez continuer l'exécution du test même après la découverte d'un problème ou l'échec du test. Le collecteur d'erreurs collecte tous les objets d'erreur et les signale une seule fois après la fin de l'exécution du test.
Dans ce didacticiel, vous apprendrez-
- Qu'est-ce que le collecteur d'erreurs dans JUnit?
- Qu'est-ce que @Rule dans jUnit?
- Exemple utilisant ErrorCollector
- Avantages de JUnit ErrorCollector
Pourquoi utiliser Error Collector?
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 pour toute autre raison. Dans ce cas, vous pouvez continuer à exécuter le script de test à l'aide d'une fonction spéciale fournie par JUnit appelée «collecteur d'erreurs».
Pour cela, JUnit utilise l' annotation @Rule qui est utilisée 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 (Throwable error). Comme vous le savez, Throwable est la super classe de la classe Exception et Error en Java. Lorsque vous ajoutez des erreurs de cette manière, ces erreurs seront consignées dans le résultat du test JUnit.
L'avantage d'ajouter toutes les erreurs dans un collecteur d'erreurs est que vous pouvez vérifier toutes les erreurs à la fois. De plus, si le script échoue au milieu, il peut continuer à l'exécuter
Remarque : dans le cas de l'utilisation d'un bloc assert simple 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, consultez 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 {@Régnerpublic ErrorCollector collector = new ErrorCollector ();@Testexemple public void () {collector.addError (new Throwable ("Il y a une erreur dans la première ligne"));collector.addError (new Throwable ("Il y a une erreur dans la deuxième ligne"));collector.checkThat (getResults (),not (containsString ("here is an error")));// toutes les lignes de code s'exécuteront et à la fin un échec combiné seraêtre connecté.}}
Qu'est-ce que @Rule dans jUnit?
JUnit fournit un type spécial de gestion des tests, des cas de test ou de la suite de tests en utilisant l' annotation @rule . En utilisant @rule, vous pouvez facilement ajouter ou redéfinir le comportement du test.
Il existe plusieurs règles intégrées fournies par l'API JUnit 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:
@Régnerpublic 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 allez ajouter toutes les erreurs en utilisant addError (throwable) ici.
Voir ci-dessous le code qui crée simplement une règle qui n'est rien d'autre que la création d'un «objet Error Collector». Qui est en outre 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 {@Régnerpublic ErrorCollector collector = new ErrorCollector ();@Testexemple public void () {collector.addError (new Throwable ("Il y a une erreur dans la première ligne"));collector.addError (new Throwable ("Il y a une erreur dans la deuxième ligne"));System.out.println ("Bonjour");essayer {Assert.assertTrue ("A" == "B");} catch (Throwable t) {collector.addError (t);}System.out.println ("Monde !!!!");}}
TestRunner.java
Ajoutons la classe de test ci-dessus dans un testeur 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) {Résultat du résultat = JUnitCore.runClasses (ErrorCollectorExample.class);for (Échec d'échec: result.getFailures ()) {System.out.println (failure.toString ());}System.out.println ("Result ==" + result.wasSuccessful ());}}
Production:
Voir la trace des échecs qui retrace toutes les erreurs en un seul endroit:
Avantages de JUnit ErrorCollector
Vous pouvez utiliser l'assertion JUnit pour la validation fonctionnelle ou GUI, par exemple
- assertEquals (message de chaîne, objet attendu, objet réel) qui comparent le fait que deux objets sont égaux.
- De même, assertTrue (condition booléenne) affirme qu'une condition est vraie.
En utilisant l'assertion, le test de validation devient facile. Mais un problème majeur est que l'exécution du test s'arrêtera même si une seule assertion échoue.
La continuité des tests et la gestion de la récupération sont essentielles 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écouverte du premier problème et l'échec du test à la fin
- Le collecteur d'erreurs collecte tous les objets d'erreur et les signale uniquement, après tout, l'exécution du test sur
- L'avantage d'ajouter toutes les erreurs dans un collecteur d'erreurs est que vous pouvez vérifier toutes les erreurs à la fois
- Error collector ajoute simplement des erreurs en utilisant la méthode addError (throwable err) fournie par ErrorCollector.java.