Menu

Suite de tests JUnit et cas de tests de filtrage: JUnit 4 vs JUnit 5

  • Principal
  • Autre
  • Suite de tests JUnit et cas de tests de filtrage: JUnit 4 vs JUnit 5

junit test suite filtering test cases

Essayez Notre Instrument Pour Éliminer Les Problèmes

comment installer le plugin svn dans eclipse

Ce didacticiel abordera ce qu'est une suite de tests JUnit, comment créer une suite de tests et comment filtrer les cas de test dans JUnit 4 vs JUnit 5:

Nous avons appris comment ignorer certains cas de test lors de l'exécution dans notre tutoriel précédent. Nous avons également découvert les différentes annotations utilisées dans JUnit 4 et JUnit 5 pour ce faire.

Dans ce tutoriel, nous allons apprendre:

  • Qu'est-ce qu'une suite de tests?
  • Comment créer une suite de tests en encapsulant plusieurs cas de test dans un groupe et en exécutant la suite à l'aide de la classe JUnitCore?

=> Visitez ici pour la série exclusive de didacticiels de formation JUnit.

Suite de tests JUnit et test de filtrage

Ce que vous apprendrez:

Suite de tests JUnit

JUnit 4: @RunWith, @SuiteClasses Annotations

Le tutoriel Plusieurs façons d'exécuter des tests JUnit illustré comment créer une suite de tests dans JUnit 4.

Les annotations @Courir avec et @SuiteClasses nous a aidés à créer une suite de tests en regroupant plusieurs classes de test JUnit. Par la suite, un fichier runner avec la classe JUnitCore.runclasses () a appelé l'exécution de la suite de tests créée.

Veuillez vous référer à la section mentionnée pour tous les détails minutieux sur le flux de travail ainsi que le code réel pour JUnit 4.

JUnit 5: @RunWith, @SelectClasses, @SelectPackages Annotations

La création d'une suite de tests en JUnit 5 est assez similaire à ce que nous avons dans JUnit 4. Alors, où est la différence alors?

#1) Dans JUnit 4 , nous avons Suite.class qui est passé en paramètre à @RunWith annotation pour prendre en charge la création d'une suite de tests alors que JUnit 5 utilise la même annotation @RunWith mais avec le paramètre d'entrée comme JUnitPlatform.class au lieu de Suite.class .

Ainsi, la ligne de code dans JUnit 5 ressemble à @RunWith (JUnitPlatform.class). Il s'agit de l'annotation fournie avec votre sous-projet JUnit Platform.

#deux) Dans JUnit 4 , nous utilisons @SuiteClasses pour regrouper plusieurs classes JUnit séparées par une virgule dans JUnit 5 on a:

  • L'annotation @SelectClasses c'est équivalent à @SuiteClasses dans JUnit 4 pour regrouper plusieurs classes JUnit.
  • @SelectPackages l'annotation est utilisée pour regrouper plusieurs tests du (des) package (s). Vous devez saisir une valeur de tableau de chaînes qui représente le package que vous souhaitez inclure.

Ainsi, en d'autres termes,

  1. Si vous souhaitez regrouper les cas de test à partir d'un seul package, JUnit 5 vous permet de le faire.
  2. Ou si vous souhaitez regrouper des cas de test à partir de plusieurs packages, JUnit 5 vous aide également à le faire. Une note à retenir ici est que les tests sous tous les sous-packages du package mentionné sont également inclus dans la suite de tests par défaut.

JUnit 5: différents scénarios / exemples

Création d'une suite de tests regroupant plusieurs classes de test

L'extrait de code est illustré ci-dessous:

@RunWith(JUnitPlatform.class) @SelectClasses({JUnit5TestCase1.class, JUnit5TestCase2.class }) public class JUnitTestSuite { }

Création d'une suite de tests pour un package unique

L'extrait de code est illustré ci-dessous:

@RunWith(JUnitPlatform.class) @SelectPackages({“ demo.tests “}) public class JUnit5TestSuite { }

Noter :

  1. Dire tests démo le paquet a un sous-paquet demo.tests.subtests.
  2. Le code @SelectPackages ({'demo.tests'}) inclura également tous les tests du sous-paquetage dans la suite de tests; par défaut.
  3. Si vous aviez déclaré @SelectPackages ({'demo.tests.subtests'}) , les cas de test sous le sous-paquet demo.tests.subtests ne seront inclus que dans la suite de tests alors que les tests de son package parent, c'est-à-dire tests démo ne serait pas inclus.

Création d'une suite de tests pour plusieurs packages

L'extrait de code pour créer une suite de tests pour plusieurs packages séparés par une virgule dans JUnit 5 - ressemblera à ceci:

@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests”, “demo1.tests”, “demo2.tests”}) public class JUnit5TestSuite { }

Suite de tests de filtrage - JUnit 4 vs JUnit 5

Parfois, nous devons filtrer les cas de test et exécuter un ensemble particulier de tests selon nos besoins. Par exemple, il pourrait y avoir un ensemble de tests identifiés pour les tests de régression, un ensemble séparé pour les tests unitaires et un ensemble séparé de cas de test pour les tests de fumée.

Nous devons exclure ou inclure des cas de test de certains packages, classes ou catégories. Filtrer ou baliser les tests à partir d'un seul package est la seule option avec JUnit4.

Comparé à JUnit 4, JUnit 5 est livré avec un bon ensemble de fonctionnalités pour prendre en charge ce besoin de filtrer vos cas de test à partir du package unique ou de plusieurs packages et sous-packages en fonction de vos besoins changeants.

JUnit 4 - @Category, @IncludeCategory, @ExcludeCategory

Les cas de test dans JUnit 4 peuvent être classés en différentes catégories. Ces catégories peuvent être exclues ou incluses lors de l'exécution de votre suite de tests. Les annotations @Category, @IncludeCategory et @ExcludeCategory sont pris en charge à partir de JUnit 4.12 et supérieur.

Les étapes de haut niveau pour créer les filtres en fonction de la ou des catégories sont les suivantes:

#1) Créez une interface de marqueur qui joue un rôle dans la catégorie.

#deux) Annoter les méthodes de test des classes à inclure dans les SuiteClasses avec @Catégorie et le nom de la catégorie.

# 3) Dans le fichier de la suite de tests, utilisez l'annotation @IncludeCategory avec le nom de la catégorie pour inclure les tests appartenant à une catégorie spécifique.

# 4) Dans le fichier de la suite de tests, utilisez l'annotation @ExcludeCategory avec le nom de la catégorie pour les exclure.

# 5) L'annotation @Category peut également être utilisée au niveau du test ou au niveau de la classe. Si l'annotation est appliquée au niveau du test, alors ce test spécifique est étiqueté avec la catégorie donnée, tandis que si l'annotation est au niveau de la classe, tous les tests de la classe sont étiquetés dans la catégorie donnée.

Examinons quelques détails supplémentaires pour comprendre la mise en œuvre pratique de la catégorisation des tests et de leur filtrage pour exécution:

Étape 1:

Nous commencerons par la création d'un interface de marqueur qui jouera le rôle d'un catégorie pour les méthodes d'essai. Ici, nous créons une catégorie nommée Test de l'unité . Le code est très simple. Veuillez vous référer au code ci-dessous.

Code pour UnitTest.java

package demo.tests; public interface UnitTest {}

Étape 2:

Nous marquerons la catégorie au niveau de la méthode d'essai dans la classe JUnitTestCase1.java . Pour ajouter le cas de test junitMethod1 () dans la catégorie UnitTest, nous devons annoter la méthode de test avec @Category (UnitTest.class) .

Cela ajoute la méthode de test à la catégorie UnitTest. Les autres méthodes de test (le cas échéant) ne sont pas étiquetées dans la catégorie à moins que les méthodes ne soient annotées avec une catégorie.

Pour que l'annotation @Category fonctionne dans notre code, nous devons importer le package org.junit.experimental.categories.Category

L'extrait de code de JUnitTestCase1.java:

@Category(UnitTest.class) @Test public void junitMethod1(){ int Value2=9000; Assert. assertEquals (Value1, Value2); }

Une méthode de test peut également appartenir à plusieurs catégories Par exemple. : @Category (UnitTest.class, SmokeTest.class)

Étape 3:

Je voudrais maintenant marquer la catégorie au niveau de la classe dans la classe JUnitTestCase2.java . La même instruction qui a été ajoutée au niveau de la méthode de test à l'étape précédente sera également ajoutée dans le fichier de classe actuel.

Notez qu'ici, nous ajouterons l'instruction au niveau de la classe. Cela fera en sorte que toutes les méthodes de test du fichier appartiennent au Test de l'unité Catégorie.

L'extrait de code de JUnitTestCase2.java:

@Category(UnitTest.class) @Test public class JUnitTestCase2 { public String stringValue='JUnit';

Étape 4:

comment construire un réseau sécurisé

Maintenant que nos cas de test requis ont été classés dans la catégorie UnitTest, nous allons maintenant voir comment les ajouter à la suite de tests en les filtrant en fonction de la catégorie. Nous apporterons certaines modifications au code dans le JUnitTestSuite.class pour le démontrer.

  • Catégories.classe sera passé en paramètre à l'annotation @RunWith.
  • @ Suite.SuiteClasses prendra le tableau de chaînes des classes de test.
  • L'annotation @ Categories.IncludeCategory aura besoin de UnitTest.class comme paramètre.
  • Cette déclaration nous aidera à filtrer la suite entière et à exécuter uniquement les cas de test de la suite qui appartient à la catégorie.
  • Categories.class a besoin d'un package org.junit.experimental.categories.Categories à importer.

L'extrait de code pour JunitTestSuite.java

@RunWith(Categories.class) @Categories.IncludeCategory(UnitTest.class) @Suite.SuiteClasses({JUnitTestCase1.class, JUnitTestCase2.class}) public class JUnitTestSuite {

L'annotation @ Categories.IncludeCategory peut également être écrit comme @IncludeCategory. Vous pouvez également créer plusieurs interfaces (catégories) et annoter la classe / les méthodes de test avec plusieurs catégories séparées par une virgule. L'exemple ci-dessous filtrera les tests appartenant à catégorie - Catégorie1 et Catégorie2.

Exemple: @IncludeCategory ({Category1.class, Category2.class})

Des règles similaires vont de pair @ Categories.ExcludeCategory / @ExcludeCategory pour exclure les méthodes de test sous la ou les catégories pendant le test.

JUnit 5 - @IncludeTags, @ExcludeTags, @IncludePackages, @ExcludePackages, @IncludeClassNamePatterns, @ExcludeClassNamePatterns

JUnit 5 est livré avec plusieurs approches pour organiser et filtrer les cas de test.

JUnit 5 - @IncludeTags, @ExcludeTags

#1) Comme JUnit 4, les annotations @IncludeCategory et @ExcludeCategory prennent en charge le filtrage des cas de test pour l'exécution.

#deux) JUnit 5 a des annotations @IncludeTags et @ExcludeTags pour atteindre le même objectif.

# 3) JUnit 4 fait référence aux cas de test à organiser dans une catégorie spécifique tandis que JUnit 5 se réfère au marquage des cas de test avec une balise spécifique pour permettre le filtrage des cas de test pour exécution.

Les étapes de haut niveau pour créer les filtres basés sur les balises sont les suivantes:

  1. Annotez les méthodes de test du ou des packages à inclure dans les @SelectPackages avec @Étiqueter et le nom de balise défini par l'utilisateur. Une classe peut avoir différentes balises pour différentes méthodes de test.
  2. Vous pouvez également annoter @Tag au niveau de la classe afin que tous les tests de la classe soient balisés.
  3. Dans le fichier de la suite de tests, utilisez l'annotation @IncludeTags avec le nom de la balise pour inclure les tests appartenant à une balise spécifique.
  4. Dans le fichier de la suite de tests, utilisez l'annotation @ExcludeTags avec le nom de la balise pour les exclure de la suite de tests.

Voyons maintenant une illustration détaillée de la mise en œuvre pratique du filtrage dans JUnit 5.

Étape 1 : Nous marquons une méthode de test dans JUnit5TestCase1.java avec le nom de la balise «Regression»

L'extrait de code de JUnit5TestCase1.java:

@Tag(“Regression”) @Test public void junitMethod1(){

Étape 2 : Nous marquons une méthode de test dans JUnit5TestCase2.java avec le nom de balise «SmokeTest».

L'extrait de code de JUnit5TestCase2.java:

@Tag(“SmokeTest”) @Test public void junitMethod2(){

Étape 3: Maintenant que les méthodes de test ont été balisées, nous allons maintenant mettre à jour JUnit5TestSuite.java pour ajouter des filtres appropriés par balises pour les tests. Le code ci-dessous comprend tous les tests marqués comme 'Régression' et exclut tous ceux marqués comme 'SmokeTest'.

L'extrait de code de JUnit5TestSuite.java:

@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludeTags(“Regression”) @ExcludeTags(“SmokeTest”) public class JUnit5TestSuite { }

JUnit 5 - @IncludePackages, @ExcludePackages

Nous savons déjà que lorsque nous passons un nom de package dans le @SelectPackages annotation, les tests dans les sous-packages du package sont également ajoutés à la suite de tests.

Il peut y avoir certains sous-packages que nous souhaitons inclure dans notre suite de tests, tandis que quelques autres sous-packages que nous ne voulons pas ou peuvent ne pas être pertinents pour être inclus dans notre suite.

Ceci est facilité par les annotations @IncludePackages et @ExcludePackages dans JUnit 5.

Supposons que nous ayons un package «demo.tests» qui a trois sous-packages à savoir sous-package1, sous-package2 et sous-package 3 avec ses classes de test dans chacun des packages ci-dessous.

package «demo.tests» avec trois sous-packages

Voyons un extrait de code de JUnit5TestSuite.java pour visualiser comment inclure et exclure un package.

Scénario 1: Appliquez le filtre pour inclure uniquement les cas de test du sous-package1.

Le code ci-dessous inclut tous les tests de toutes les classes JUnit du package demo.tests.subpackage1, cependant, exclut tous les tests directement sous le package demo.test et ceux sous le package subpackage2 et subpackage3.

L'extrait de code de JUnit5TestSuite.java:

@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludePackages(“demo.tests.subpackage1”) public class JUnit5TestSuite { }

Scénario n ° 2: Appliquer le filtre pour exclure les cas de test uniquement du sous-paquetage 3.

Le code ci-dessous exclut tous les tests des classes JUnit dans le package - demo.tests.subpackage3 cependant la suite inclut tous les tests directement sous le package demo.test et ceux sous les packages subpackage1 et subpackage2.

L'extrait de code de JUnit5TestSuite.java:

@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @ExcludePackages(“demo.tests.subpackage3”) public class JUnit5TestSuite { }

JUnit 5 - @IncludeClassNamePatterns, @ExcludeClassNamePatterns

Lorsque vous souhaitez inclure ou exclure certaines classes correspondant à une expression régulière spécifique du package, les annotations @ InclureClassNamePatterns et @ ExclureClassnamePatterns peut être utilisé dans le fichier de classe de la suite de tests.

Voyons maintenant l'illustration à travers la mise à jour du code dans JUnit5TestSuite.java

Scénario 1:

Le code ci-dessous comprend les classes qui se terminent par «Ctests» du package demo.tests

@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludeClassNamePatterns({'^.*CTests?$'})

Scénario n ° 2:

Nous allons maintenant exclure les classes qui lancer avec «STest» du package demo.tests

@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @ExcludeClassNamePatterns({'^STest.*$'})

Scénario n ° 3:

Plusieurs expressions régulières peuvent également être passées comme critères de filtre. Le code ci-dessous indique deux expressions régulières différentes séparées par le ' OU ”Opérateur. La barre à fente | est l'opérateur OR ici.

quel est le meilleur dissolvant de logiciels espions

Le code filtre les classes initier avec Test ( Test.*) ou fin avec Tests (*. Tests?) et inclut ces classes dans la suite de tests en tant qu'annotation @IncludeClassNamePatterns est utilisée.

Noter: Si le nom de classe qualifié complet correspond à au moins un modèle, la classe sera récupérée par l'annotation @IncludeClassNamePatterns ou @ExcludeClassNamePatterns.

@RunWith (JUnitPlatform.class)

@SelectPackages ({'demo.tests'})

@IncludeClassNamePatterns (. * Tests?) $ ”)

FAQ sur les cas de test de filtrage JUnit

Voici une question qui vous préoccupe peut-être depuis un certain temps déjà.

Q # 1) Quelle est la différence entre désactiver / ignorer un test et filtrer un test? L'une ou l'autre des fonctionnalités ne peut-elle pas servir le même objectif d'ignorer les scénarios de test pendant l'exécution?

Réponse: La question est en effet authentique et mérite une réponse.

  1. Avec la fonction de test de filtrage, vous pouvez exclure ainsi que comprendre tests en fonction de la catégorie étiquetée. Alors que, avec la désactivation, vous pouvez décider uniquement d'exclure et de ne pas inclure les tests pour l'exécution.
  2. Filtrer les cas de test est une sorte de cas de test à sauter conditionnellement alors que, dans le cas des tests ignorés, ceux-ci sont ignorés sans conditions.
  3. Une autre différence significative entre les deux est que lorsque vous exécutez les cas de test avec des tests annotés avec @Ignore ou @Disabled - les tests ignorés apparaissent dans les résultats de test sous le PASSE compter
  4. Lorsque vous exécutez les tests filtrés, ils n'apparaissent pas du tout dans le résultat du test.

Conclusion

Dans ce didacticiel, nous avons appris à filtrer les tests en ajoutant une catégorie / balise aux tests.

Nous avons appris dans JUnit 4, que nous avons @Category, @IncludeCategory et @ExcludeCategory pour filtrer les cas de test tandis que JUnit 5 a @IncludeTags et @ExcludeTags pour faire de même.

En outre, JUnit 5 dispose d'options de filtrage supplémentaires utilisant les annotations @IncludePackages, @ExcludePackages, ainsi que des annotations pour inclure ou exclure des classes à l'aide de modèles de nom de classe. Plus nous explorons; nous nous rendons compte qu'il reste encore beaucoup à explorer.

=> Regardez la série de formation JUnit simple ici.

lecture recommandée

^