Introduction sur les annotations JUnit
JUnit est l'un des frameworks de test open source et Java les plus puissants disponibles gratuitement sur le marché. Il aide à la création et à l'exécution de cas de test faciles et rapides en fonction des exigences à l'aide d'annotations. Les annotations fournissent essentiellement des informations supplémentaires sur les classes et les méthodes utilisées dans le code Java. Il aide à effectuer des tests sur chaque composant unitaire, que ce soit les méthodes, les classes, les packages et les variables. Il est couramment utilisé pour les tests unitaires des applications. La dernière mise à niveau de JUnit est JUnit5. Il prend en charge le pilote Web Selenium pour les tests d'automatisation des applications Web et mobiles. org. Junit est le package qui contient toutes les interfaces et classes pour les tests via JUnit.
Annotations JUnit avec exemple
Vous trouverez ci-dessous certaines des annotations JUnit:
1. @Before
Il existe des scénarios dans lesquels certains cas de test ou données de test doivent être créés avant l'exécution du cas de test réel. Dans ce cas, les annotations @Before sont apparues dans l'image. L'annotation de toute méthode publique avec cette annotation permet au code / méthode de s'exécuter avant chaque méthode @test réelle. Dans le cas de l'héritage, les méthodes @before de la superclasse sont appelées d'abord, puis les méthodes @before de la classe courante.
2. @After
C'est tout le contraire de l'annotation @Before. Il est utilisé dans les cas où certaines actions doivent être effectuées comme la libération de ressources, le nettoyage de la mémoire, l'impression de tout sur la console après l'exécution de la méthode @test (après l'exécution de chaque cas de test). Il y a un point important à noter pour l'annotation @After, c'est qu'elle s'exécutera même dans le cas où les méthodes @test ou @before lèveront une exception. Dans le cas d'une relation de sous-classe et de super-classe, la méthode @after de la sous-classe / classe actuelle est exécutée avant la méthode @after de la super-classe.
3. @BeforeClass
Cette annotation est utilisée dans les scénarios lorsque certaines actions doivent être effectuées avant l'exécution de n'importe quel scénario de test d'une classe particulière comme la création d'une connexion avec la base de données, la création d'une entrée dans une base de données, une entrée dans les journaux, etc. Lorsque @BeforeClass l'annotation est utilisée avant toute méthode, cette méthode s'exécute avant toute méthode de test dans une classe. Son fonctionnement est similaire à l'annotation @Before, seule différence étant que @Before exécute la méthode avant l'exécution de chaque méthode @test tandis que @BeforeClass ne s'exécute qu'une seule fois, c'est-à-dire avant l'exécution de toute méthode @test dans une classe.
4. @AfterClass
Toutes les ressources allouées dans la méthode @BeforeClass doivent être libérées après l'exécution de toutes les méthodes @test de la classe actuelle. Cette désallocation des ressources ou toute tâche importante qui doit être effectuée après l'exécution de la classe entière est effectuée par la méthode @AfterClass. En termes simples, la méthode @AfterClass s'exécute après l'exécution de toutes les méthodes @test de la classe actuelle. Il n'est exécuté qu'une seule fois. Les méthodes @AfterClass sont exécutées de manière obligatoire même si les méthodes @BeforeClass lèvent une exception.
Comme la méthode @After, le fonctionnement de la méthode @AfterClass est similaire, sauf que la méthode @After est exécutée après chaque méthode @test de la classe tandis que la méthode @AfterClass est exécutée une fois après l'exécution de toutes les méthodes @test d'une classe.
5. @Test
Cette annotation spécifie que la méthode publique sous cette annotation fait partie du scénario de test principal qui doit être exécuté. La méthode sous @test définit le cas de test comme réussi ou échoué selon que des exceptions / erreurs se produisent lors de son exécution.
Il peut également être utilisé de 2 manières:
- @Test (timeout = 500): il prend le paramètre comme timeout qui accepte les valeurs en millisecondes. Il considère le cas de test comme ayant échoué lorsqu'il prend plus de temps que prévu pour s'exécuter et réussir lorsqu'il s'exécute avec succès dans le délai spécifié.
- @Test (attendu = Exception.class): Il existe des situations où nous voulons que certaines méthodes lèvent une exception spécifique. Le cas de test échoue si la méthode ne lève aucune exception ou l'exception mentionnée ci-dessus.
6. @Ignore
Il existe des scénarios où nous voulons ignorer quelques cas de test et ne pas les exécuter. @Ignore aide pour la même chose. Les méthodes sous les annotations @Ignore ne sont pas exécutées et sont ignorées lors de l'exécution du code. Même dans les rapports générés par TestNG montre le nombre de cas de test qui sont ignorés et le nombre de cas de test réussis.
Exemple
Prenons un exemple d'annotations JUnit
package demo;
import org.junit.*;
public class JUnitAnnotationTest (
// Run once, before any @test method in the class are executed
@BeforeClass
public static void bClass() (
System.out.println("BeforeClass method is called”);
)
// Run once after all the @test methods of the class are executed
@AfterClass
public static void aClass() (
System.out.println("AfterClass method is called");
)
// Run before every @test method of a class is executed
@Before
public void bMethod() (
System.out.println("before method is called");
)
// Run after every @test method of class is executed
@After
public void aMethod() (
System.out.println("after method is called");
)
// Test method which has actual test case
@Test
public void testMethod() (
System.out.println("Test method is called");
)
)
Production:
Avantages des annotations JUnit
Vous trouverez ci-dessous certains des avantages des annotations JUnit:
- JUnit fournit un moyen facile d'exécuter les cas de test d'une manière spécifique en fonction des besoins de l'utilisateur.
- Il est facile d'exécuter les multiples cas de test en parallèle à l'aide de JUnit en les combinant dans une suite de tests.
- Les annotations JUnit utilisées pour automatiser les cas de test dans Selenium fournissent à l'utilisateur un rapport graphique très détaillé et interactif qui est également très convivial.
- JUnit permet de passer les paramètres de la méthode de manière très simple.
- L'annotation JUnit permet d'effectuer un codage propre qui est très facile à comprendre pour les testeurs et les programmeurs.
Conclusion
L'explication ci-dessus décrit clairement l'importance du cadre JUnit et l'ordre dans lequel diverses annotations de JUnit sont appelées. Il est très important de comprendre les différentes annotations avant de les utiliser dans un programme afin que cela ne crée aucun problème de contrôle du flux d'exécution.
Articles recommandés
Ceci est un guide des annotations JUnit. Nous discutons ici de l'introduction et des annotations de JUnit avec un exemple qui inclut @ Before, @ After, @ Test et @Ignore, etc. Vous pouvez également consulter nos autres articles suggérés pour en savoir plus -
- Tests unitaires
- Test de boîte blanche
- Architecture de sélénium
- Harnais de test