JUnit est un framework de test unitaire open source tiers. Le projet a été lancé par Kent Beck et Erich Gamma à la fin de 1995. Il a rapidement suscité l'intérêt de la communauté des développeurs qui s'occupent particulièrement du développement piloté par les tests. JUnit a été initialement introduit sur Smalltalk, mais a ensuite été porté sur Java, qui l'a rapidement adopté comme norme de facto des tests unitaires. La popularité de JUnit a augmenté au point que, pour répondre aux besoins de nombreux autres langages contemporains tels que C#, Perl, Python, PHP, Ruby, Visual Basic, C++, etc., un framework xUnit générique a été développé où la lettre 'x' est remplacé par la première lettre du langage, comme JUnit pour Java, RUnit pour Ruby, etc. Cet article donne un aperçu de ce framework tel qu'il est utilisé par la norme de facto des tests unitaires Java.
Présentation des tests
Le test est une phase importante dans le cycle de vie du développement d'une application. Le but principal des tests est d'évaluer un programme sur la base des spécifications requises. L'objectif est de créer certains cas de test qui mettent en évidence les erreurs, les lacunes, les écarts ou les résultats inattendus, autant que possible. Ce concept simple est associé à des processus élaborés. Mais, pour le dire brièvement, cela se fait à trois niveaux. Lorsque le test est effectué au niveau très granulaire ou de composant individuel, il s'appelle Test unitaire; lorsqu'ils sont combinés pour vérifier les interfaces entre les composants par rapport à une conception logicielle, cela s'appelle Test d'intégration; et enfin, lorsque le système complet est intégré et que des tests sont effectués pour vérifier que le système dans son ensemble répond aux exigences spécifiées, cela s'appelle Test du système .
Tests unitaires
En un mot, effectuer un test unitaire est un moyen d'examiner le comportement d'une unité de code distincte. En Java, une unité de code peut signifier une méthode ou une classe ou même un module, selon le contexte. S'il s'agit d'une méthode, par exemple, l'objectif du test est d'évaluer la bonne référence d'objet autorisée à invoquer la méthode, le type de paramètres et les valeurs acceptables, les plages de valeurs primitives, le type et la valeur de retour, etc. L'idée est de griller la méthode afin qu'elle puisse être rendue suffisamment robuste pour gérer avec grâce son problème et rejeter ceux qui dépassent son champ d'application en dehors de l'exécution de son contrat.
Par conséquent, les tests unitaires constituent la pierre angulaire de toute évaluation de programme. En fait, chaque programmeur effectue une sorte de test unitaire lorsque l'on écrit du code pour vérifier le résultat du code avec des données/cas factices. Les tests unitaires sont donc un statut formel donné à cet ensemble isolé de tests. Il est extrêmement important qu'un code passe par la rigueur des différentes phases de test. Le test unitaire, outre son importance, il est aussi très banal. Des personnes telles que Kent Beck et Erich Gamma ont pensé à créer un cadre pour que les programmeurs obtiennent un environnement structuré et puissent automatiser bon nombre de ces tâches. Après tout, c'est à cela que sert un cadre. En règle générale, il fournit une structure de programme cohérente qui est réutilisable et partageable entre les applications. Un programmeur peut les intégrer dans une application existante et les étendre selon son besoin spécifique.
Un exemple rapide
Un code de test unitaire simple pour examiner la méthode unique en température class sans utiliser le framework JUnit est le suivant :
package org.mano.unittest.examples;
public class Circle {
double area(double radius) {
returnMath.PI* radius * radius;
}
}
Maintenant, écrivons le code pour tester unitairement la zone méthode.
package org.mano.unittest.examples;
public class CircleTest {
public int errCounter= 0;
public void testCircleArea() {
Circle circle = new Circle();
double area = circle.area(12);
if (area < 452 && area > 453) {
throw new IllegalStateException("Wrong calculation!: "
+ area);
}
}
public static void main(String[] args) {
TestCircle test = new TestCircle();
try {
test.testCircleArea();
} catch (Throwable e) {
test.errCounter++;
e.printStackTrace();
}
if (test.errCounter> 0) {
throw new IllegalStateException("There were "
+ test.errCounter+ " error(s)");
}
}
}
Ceci est un exemple rudimentaire, mais vous donne une idée de la façon dont les tests unitaires peuvent être effectués sans utiliser de framework.
Cadre de test JUnit
L'utilisation du framework JUnit pour les tests unitaires présente plusieurs avantages. Il fournit de nombreuses annotations qui facilitent l'écriture et l'exécution de codes de test en Java :
- Essentiellement, il sépare la préoccupation des tests unitaires du code de projet réel en permettant de créer une instance de classe de test et des chargeurs de classe pour chaque test unitaire. Ceux-ci "immunisent" le code existant contre les effets secondaires inutiles des tests.
- Les annotations fournies par JUnit, telles que @Before, @After, @BeforeClass, @AfterClass —avoir des méthodes pour l'initialisation et la récupération des ressources.
- Il existe une grande variété de méthodes d'assertion pour vérifier le résultat d'un test.
- Au fil des ans, JUnit est devenu si populaire que de nombreux outils Java, tels que Ant et Maven; et les IDE populaires, tels que Eclipse , NetBeans , IntelliJ IDÉE , et autres, sont livrés avec l'intégration intégrée de JUnit.
Pour utiliser le framework de test JUnit dans un projet Java, il faut ajouter un fichier JAR JUnit dans le chemin de classe du projet. Ceci est explicitement requis si l'IDE n'est pas intégré à la bibliothèque JUnit. Le processus est simple. Téléchargez le fichier JAR et ajoutez-le au chemin de classe du projet.
Voici quelques liens importants vers le framework JUnit.
- Site officiel de JUnit
- API Java JUnit
- Guide d'utilisation de JUnit
- Code source JUnit dans GitHub
Contrairement à JUnit 4 et à ses prédécesseurs, JUnit 5 a apporté des changements importants. Outre de nombreuses nouvelles fonctionnalités ajoutées, telles que la prise en charge de lambda, de nouvelles annotations et l'injection de paramètres de méthode de test, l'architecture de base a subi des modifications importantes. JUnit 5 est désormais une architecture composite de trois modules différents :JUnit Jupiter, JUnit Vintage et JUnit Platform. Les développeurs de cas de test, cependant, n'ont pas besoin de se soucier de la complexité des modifications. Les changements signifient principalement une meilleure prise en charge des outils, une cohérence et des API plus propres. Surtout, il est totalement rétrocompatible avec JUnit 4. Donc, pas de soucis non plus. Reportez-vous au guide de l'utilisateur JUnit 5 pour plus de détails.
Un exemple rapide
Voici un exemple très simple pour avoir un aperçu de la façon dont les tests unitaires peuvent être effectués avec le framework JUnit. Nous utilisons le Employé classe pour le test unitaire et créez une classe de test pour donner une idée de son fonctionnement. L'exemple est rudimentaire dans la mesure où il s'agit d'écrire un programme "Hello World". Des cas de test réels, ou même un exemple décent de test unitaire, nécessitent une bonne quantité de code. Nous essaierons peut-être cela dans un autre article.
package org.mano.unittest.examples;
public class Employee {
private final String name;
private final double basicPay;
public Employee(String name, double basicPay) {
this.name=name;
this.basicPay=basicPay;
}
public String getName() {
return name;
}
public double getBasicPay() {
return basicPay;
}
}
package org.mano.unittest.examples;
import org.junit.Test;
import static org.junit.Assert.*;
public class EmployeeTest {
@Test
public void constructorInitTest(){
Employee emp=new Employee("Odin", 2300);
assertEquals("Odin", emp.getName());
assertEquals(2300, emp.getBasicPay(), 0.001);
}
}
package org.mano.unittest.examples;
public class EmployeeTestMain {
public static void main(String[] args){
EmployeeTest et=new EmployeeTest();
et.constructorInitTest();
}
}
Observez que la classe Employee est immuable avec seulement deux champs définis par le constructeur. Parce que seule la méthode constructeur vaut la peine d'être testée, nous ne testerons que celle-là.
La classe de test est nommée EmployeeTest selon les conventions. L'annotation @Test permet à JUnit de désigner une méthode comme méthode de test. Il existe une variété de méthodes d'assertion dans Assert classe. Ici, nous avons utilisé uniquement assertEquals .
Il existe de nombreuses façons d'exécuter un test écrit en JUnit. En règle générale, après l'exécution des cas de test, il imprime un résumé. Cependant, cela peut varier en fonction de la manière dont le test est exécuté. Il peut fonctionner via des IDE comme Eclipse ou IntelliJ, ou des outils comme Maven, Gradle, etc. Parfois, la seule information reçue après le test est qu'il a échoué ou réussi.
Conclusion
Il existe plusieurs autres frameworks pour les tests unitaires. JUnit est un framework de test unitaire populaire parmi la communauté Java. Les tests en tant que phase d'ingénierie système impliquent beaucoup plus de processus. Les tests unitaires n'en sont qu'une partie et, fait intéressant, de nombreux tests de jeu effectués par le développeur peuvent être qualifiés de tests unitaires. JUnit, en tant que framework de test, lui ajoute de la valeur. Les annotations et les API fournies par JUnit automatisent de nombreuses tâches et facilitent grandement la vie des développeurs de tests unitaires.
