JUnit

Fiche logiciel validé
  • Création ou MAJ importante : 13/01/11
  • Correction mineure : 31/01/12
Mots-clés

JUnit : Développement de tests unitaires Java

Description
Fonctionnalités générales

JUnit est un framework de tests unitaires pour le langage Java créé par Kent Beck et Erich Gamma. Les tests unitaires permettent de vérifier si le comportement de chaque méthode de chaque classe Java est bien celui désiré en fonction des entrées que l'on soumet (jeux de test/scénario).

JUnit fournit donc un cadre de développement et d'exécution pour ce type de tests.

JUnit est particulièrement adapté aux développeurs souhaitant faire du développement dirigé par les tests (Tests Driven Development) dont la particularité majeure est de développer le test unitaire avant le code lui-même. On décrit donc, par l'écriture d'un test unitaire, le comportement attendu d'une classe et ce n'est qu'à partir de ce moment que l'on commence à écrire le code de cette classe de façon à ce qu'elle passe le test. Si les tests sont correctement écrits et complets, on s'assure donc de développer des classes sans erreurs et répondant exactement à nos besoins.
JUnit est également un outil particulièrement utile pour réaliser des tests de non-régressions du fait qu'il permet d'avoir des tests automatisés et rejouables. En ré-exécutant les suites de tests après une correction, une modification ou une évolution du code, on peut s'assurer qu'il n'y a pas eu d'effets de bords sur le comportement du logiciel qui était déjà codé.
Enfin, on peut noter que la mise en place de tests unitaires permet d'améliorer les conditions de "transmissibilité" d'un code du développeur/auteur vers un autre développeur, en sécurisant les interventions d'un novice dans le code : cette démarche participe à un apport organisationnel, libérant, dans une certaine mesure, le développeur/auteur des tâches de maintenance.

Autres fonctionnalités

Il existe des tâches Ant permettant d'exécuter les tests et d'écrire les résultats dans des fichiers XML pour générer des rapports HTML présentant les résultats des tests.
Il existe aussi un plugin Maven pour générer ce type de rapports.

Interopérabilité

JUnit a été porté dans d'autre langage :
Ada (AUnit)
C# (NUnit)
C++ (CPPUnit)
Fortran (fUnit)
Delphi (DUnit)
Free Pascal (FPCUnit)
JavaScript (JSUnit)
Objective-C (OCUnit)
Perl (Test::Class and Test::Unit)
PHP (PHPUnit)
Python (PyUnit)
R (RUnit)
Haskell (HUnit)

Contexte d'utilisation dans mon laboratoire/service

Nous utilisons JUnit à travers le plugin Eclipse pour l'écriture de tests pour des applications Java (Web ou non) majoritairement pour des classes déjà existantes (très peu de développement dirigé par les tests).

Limitations, difficultés, fonctionnalités importantes non couvertes

L'utilisation de tests unitaires est un énorme atout pour le développement de logiciels de meilleure qualité. Cependant, l'utilisation de ce type d'outil ne garantit en aucun cas que le logiciel est complètement testé et qu'aucun bug n'est présent. En particulier, JUnit ne permet pas de réaliser :

  • Les tests d'intégration
  • Les tests fonctionnels
  • Les tests de couverture de code
  • Les tests de montée en charge

Il ne permet pas non plus de séparer les jeux de données des tests eux-mêmes.

D'autres outils (libres et commerciaux) existent sur le marché pour ce type de test.

L'écriture et l'exécution des tests unitaires lors d'un développement, que les tests soient écrits avant ou après le codage des classes, représente une charge de travail non-négligeable. Il y a encore souvent débat pour savoir si le temps passé à développer les tests unitaires est réellement justifié par un nombre suffisamment important de bugs détectés par ce moyen.
Cependant, on sait que plus les bugs sont détectés tardivement, plus ils sont difficiles et coûteux à corriger. Les tests unitaires présentent l'avantage indéniable de permettre une détection anticipée des bugs, donc une correction plus précoce, et par conséquent un gain sur le coût de la correction. Donc, si on s'interroge sur le rapport entre le temps passé à corriger des bugs tardivement dans un projet et le temps passé à les corriger quand ils sont détectés très tôt, on peut dire que les tests unitaires donnent de bons résultats (sans tenir compte de leurs nombreux autres avantages...).

La mise en œuvre précoce de tests unitaires est particulièrement bien adaptée à une approche "Test Driven Development". Pour les autres approches, l'utilisation des tests unitaires devrait se faire par rapport au besoin identifié : par exemple partage de code, sécurisation d'un changement important de code, clôture d'une phase du projet, .....

Environnement du logiciel
Distributions dans lesquelles ce logiciel est intégré

Nativement, JUnit fournit 3 programmes d'exécution des tests (TestRunner) : un en ligne de commande et 2 à partir d'une interface graphique (AWT et Swing). Cependant, la majorité des IDE Java intègrent cet outil par l'intermédiaire de plugins : Eclipse, Netbeans, IntelliJ IDEA, JBuilder,...

Plates-formes

Machines virtuelles Java

Logiciels connexes

Il existe des frameworks de tests unitaires pour bien d'autres langages dont certains sont des portages de JUnit. D'une façon générale, on parle de la famille des frameworks de tests unitaires sous le nom de xUnit :

Dans le cadre de développement de tests unitaires en Java, on peut associer JUnit à des outils de créations de bouchons ou simulacres d'objets (mock objects). Ce type d'objet permet de simuler des objets complexes dont on a besoin pour exécuter certains tests ou des objets non encore implémentés.

Il est bien souvent utile de savoir si les tests unitaires sont exhaustifs c'est à dire si toutes les méthodes sont bien testées et même si chaque ligne de code est bien exécutée au moins une fois lors de l'exécution des tests, si tous les chemins possibles sont bien parcourus. C'est ce qu'on appelle la couverture des tests. Des outils existent pour vérifier la couverture des tests JUnit :

Il existe également des outils permettant de générer automatiquement les tests unitaires d'une classe et par extension, de tout un projet :

Autres logiciels aux fonctionnalités équivalentes

En ce qui concerne les tests unitaires au sens strict du terme dans le monde Java, JUnit a peu d'équivalents.

  • TestNG qui possède aussi des plugins d'intégration aux principaux IDE

Les autres outils relatifs aux tests sont généralement des extensions de JUnit ou ciblent d'autres types de tests dont voici une liste non-exhaustive :

  • WebTest : Open Source, pour applications Web, basé sur JUnit, centré sur la séparation entre les jeux de données et les tests.
  • Watij : Open Source, pour applications Web.
  • JWebUnit : Open Source, pour applications Web.
  • JXUnit : Open Source, centré sur la séparation entre les jeux de données et les tests.
  • JTestCase : Open Source, centré sur la séparation entre les jeux de données et les tests.
  • JFunc : Open Source, extension de JUnit pour les tests fonctionnels.
  • The Grinder : Open Source, orienté sur les tests de montée en charge.
  • JUnitEE : Open Source, fournit notamment une solution pour exécuter les tests JUnit dans une application J2EE.
  • Actiwate : Gratuit, pour les applications Web.
  • StrutsTestCase : Open Source, pour tester les actions des applications Web basées sur Struts.
  • JSFUnit : Open Source, tests des applications basées sur les JSF (Java Server Faces)
  • Cactus : Open Source, basé sur JUnit, pour les tests des applications J2EE.
  • ITP : Open Source, pour les applications Web.
  • WebInject : Open Source, pour les interfaces accessibles par HTTP (pages Web, Web Services).
  • JSystem : Open Source, tests système et fonctionnels.
  • Mauve : Open Source, tests sur les librairies Java.
  • JUnitPP : Open Source. Étend JUnit en proposant le chargement des jeux de données à partir de fichier properties.
  • JUnitPerf : Open Source, permet de mesurer le temps d'exécution des tests et de simuler plusieurs utilisateurs simultanés.
  • IValidator : Open Source, orienté sur les tests d'intégration dont les cas de tests sont décrit en XML.
  • Fitnesse : Open Source. Englobe un serveur Web, un wiki et un framework d'écriture de tests.
  • JTest : Commercial.
  • Tento : Commercial.
  • GJTester : Commercial.
Environnement de développement
Eléments de pérennité

Ce projet a été fondé par des leaders dans le domaine du génie logiciel Kent Beck (eXtreme Programming) et Erich Gamma (Design Pattern).
JUnit est LA référence pour les tests unitaires dans le monde Java depuis déjà plusieurs années. Une nouvelle version complétée et améliorée est produite environ tous les ans: le site junit.org est maintenu par une équipe de la société ObjectMentor, et les nouvelles versions sont produites par une équipe de 7 développeurs parmi lesquels on retrouve E. Gamma

Références d'utilisateurs institutionnels

Le CNAM, l'ENSICA, l'ENSEEIHT, l'INSA assurent une formation à JUnit dans leurs cursus.

Environnement utilisateur
Liste de diffusion ou de discussion, support et forums

Il existe un groupe de discussion Yahoo autour de JUnit : http://tech.groups.yahoo.com/group/junit
et une liste consacrée aux annonces autour des modifications/évolutions de JUnit : https://lists.sourceforge.net/lists/listinfo/junit...

Documentation utilisateur

http://junit.sourceforge.net/#Documentation
Il existe beaucoup d'excellents tutoriaux sur la toile pour débuter avec JUnit : http://gfx.developpez.com/tutoriel/java/junit/

Divers (astuces, actualités, sécurité)

Depuis la version 4.0, l'écriture de tests et de suites de tests est simplifiée grâce aux annotations introduites par Java 5.
Dernière version (4.8.2) sortie en avril 2010.

Vous trouverez la description des patrons de conception (Design Pattern) de Junit ici.

Contributions

Il est possible de contribuer au niveau des développements : http://sourceforge.net/project/memberlist.php?grou...
Il est possible également de contribuer en proposant de nouveaux outils, articles, expériences, .. : http://www.junit.org/contribute