Tutoriel JUnit: Configuration, écriture et exécution de tests unitaires Java

Comprenez les bases et faites évoluer votre pratique de test unitaire comme un pro avec ce didacticiel.

Voulez-vous ignorer les bases et voir comment automatiser génération de tests unitaires améliorée avec l'IA passer de 0 à 60 % de couverture de code en moins de 5 minutes ? Découvrez Jtest >>

Points clés à retenir

• JUnit est la norme de test de facto de Java. JUnit est le framework le plus utilisé pour écrire et exécuter des tests unitaires automatisés, permettant de détecter les bugs dès les premières étapes du développement.
• Le framework JUnit est mature et en constante évolution. JUnit continue d'évoluer pour répondre aux besoins des développeurs Java, en intégrant de nombreuses fonctionnalités qui prennent en charge tous les aspects d'une pratique de tests unitaires robuste.
• La configuration est simple. JUnit est préconfiguré dans les IDE populaires comme Eclipse et IntelliJ, tandis que les systèmes de construction comme Maven et Gradle peuvent être configurés pour utiliser JUnit en quelques lignes de configuration, quelle que soit la version utilisée.
• Les tests JUnit suivent un modèle structuré. Le framework JUnit fournit une API simple pour la définition des tests, tandis que le format Given-When-Then offre une organisation utile pour le code de test.
• Les tests JUnit peuvent être exécutés n'importe où. Les tests peuvent être exécutés directement dans l'IDE pour obtenir un retour d'information rapide pendant le développement ou via les commandes Maven ou Gradle, les pipelines CI/CD et la ligne de commande pour une exécution automatisée.
• Les frameworks de simulation peuvent être facilement intégrés. Lorsque le code testé dépend de systèmes externes ou d'objets complexes, des frameworks de simulation comme Mockito peuvent être utilisés pour isoler le code en simulant les dépendances, permettant ainsi des tests unitaires ciblés et fiables sans effets secondaires.
• L'IA accélère les tests JUnit à grande échelle. Parasoft Jtest génère automatiquement des cas de test, des mocks et des assertions directement dans l'IDE ou les flux de travail de demandes d'extraction, aidant ainsi les équipes à atteindre une couverture de code importante tout en réduisant de plus de 50 % les efforts de création et de maintenance des tests.

Qu'est-ce que le test JUnit ?

JUnit est le framework de test unitaire Java le plus populaire. Un framework open-source, il est utilisé pour écrire et exécuter des tests automatisés reproductibles.

JUnit s'est imposé comme la norme de facto pour les tests unitaires Java grâce à une combinaison de fonctionnalités puissantes et bien conçues, fonctionnant en parfaite harmonie. Premier framework de tests unitaires développé à ce jour, il demeure le choix privilégié des développeurs Java du monde entier grâce à ses caractéristiques uniques et à son évolution constante.

Quelles sont les principales caractéristiques de JUnit et les différences majeures entre les versions ?

Comme pour tout le reste, le framework de test JUnit a évolué au fil du temps.

JUnit 4.0 est sorti en 2006, la version 5.0 en 2017 et la version 6.0 en septembre 2025.

En février 2026, la dernière version est la 6.0.2.

• JUnit 5.x Nous avons migré vers une architecture modulaire et résolu bon nombre des limitations antérieures de JUnit.
• JUnit 6.x est une version plus douce qui conserve l'approche JUnit 5, mais qui a modernisé et simplifié davantage le framework.
• JUnit 4 et 5 Les deux bénéficient encore de taux d'utilisation élevés, mais l'avenir appartient probablement à JUnit 6.

Voici quelques-uns des aspects et fonctionnalités clés de JUnit, ainsi que les différences entre les versions :

Travailler ensemble pour des tests complets

Ces fonctionnalités se combinent de manière synergique pour créer un cadre complet et extensible qui prend en charge les pratiques de développement logiciel professionnelles.

• Testez l'isolation et la cohérence. Les méthodes de configuration et de démontage garantissent que chaque test démarre dans un état prédéfini souhaité.
• Flexibilité organisationnelle. Les suites de tests, les tests imbriqués et le balisage permettent d'organiser et d'exécuter les tests appropriés au bon moment.
• Expression de test claire. L'API principale fournit les outils nécessaires pour écrire des tests compréhensibles et maintenables.
• Évolutivité Convient aussi bien aux développeurs individuels écrivant quelques tests qu'aux équipes d'entreprise gérant des milliers de tests répartis sur plusieurs modules.

Comment configurer les tests JUnit

Alors, entrons dans le vif du sujet. Voici les étapes pour configurer JUnit.

Les IDE les plus courants, tels qu'Eclipse et IntelliJ, auront déjà l'intégration des tests JUnit installée par défaut.

Si vous n'utilisez pas d'IDE et que vous vous appuyez uniquement sur un système de construction tel que Maven ou Gradle, la configuration de JUnit est gérée respectivement via le fichier pom.xml ou build.gradle.

Il est important de noter que Unité 5 a été divisé en trois modules, dont l'un est un module vintage qui prend en charge l'exécution de Unité 4 et trois tests de Unité 5.

Unité 6 conserve cette architecture.

Unité 3 Son utilisation est très faible à ce stade et ne se rencontre généralement que dans des projets beaucoup plus anciens.

Comment configurer JUnit 6

En raison du caractère modulaire de JUnit 6, un POM de nomenclature est utilisé pour importer tous les modules et dépendances JUnit. Si seuls des modules spécifiques sont nécessaires, des groupes ou des artefacts individuels peuvent être spécifiés.

Pour ajouter JUnit 6 à Maven, ajoutez ce qui suit à pom.xml:

<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>org.junit</groupId>
			<artifactId>junit-bom</artifactId>
			<version>6.0.2</version>
			<type>pom</type>
			<scope>import</scope>
		</dependency>
	</dependencies>
</dependencyManagement>
<dependencies>
	<dependency>
		<groupId>org.junit</groupId>
		<artifactId>junit-bom</artifactId>
		<version>6.0.2</version>
		<scope>test</scope>
	</dependency>
</dependencies>

Pour Gradle, ajoutez ce qui suit au fichier build.gradle :

dependencies {
	testImplementation platform("org.junit:junit-bom:6.0.2")
	testImplementation "org.junit.jupiter:junit-jupiter-api"
	testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine"
	testRuntimeOnly "org.junit.platform:junit-platform-launcher"
}
test {
	useJUnitPlatform()
}

Comment configurer JUnit 5

En raison du caractère modulaire de JUnit 5, un POM de nomenclature est utilisé pour importer tous les modules et dépendances JUnit. Si seuls des modules spécifiques sont nécessaires, des groupes ou des artefacts individuels peuvent être spécifiés.

JUnit 5 est configuré de la même manière que JUnit 6 :

<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>org.junit</groupId>
			<artifactId>junit-bom</artifactId>
			<version>5.14.2</version>
			<type>pom</type>
			<scope>import</scope>
		</dependency>
	</dependencies>
</dependencyManagement>
<dependencies>
	<dependency>
		<groupId>org.junit</groupId>
		<artifactId>junit-bom</artifactId>
		<version>5.14.2</version>
		<scope>test</scope>
	</dependency>
</dependencies>

Pour Gradle, ajoutez ce qui suit au fichier build.gradle :

dependencies {
	testImplementation platform("org.junit:junit-bom:5.14.2")
	testImplementation "org.junit.jupiter:junit-jupiter-api"
	testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine"
	testRuntimeOnly "org.junit.platform:junit-platform-launcher"
}
test {
	useJUnitPlatform()
}

Comment configurer JUnit 4

Pour ajouter JUnit 4 à Maven, ajoutez ce qui suit à pom.xml.

<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.13.2</version>
	<scope>test</scope>
</dependency>

Pour Gradle, ajoutez ce qui suit au build.gradle:

dependencies {
	testImplementation 'junit:junit:4.13.2'
}
test {
	useJUnit()
}

Si vous devez ajouter manuellement JUnit au classpath pour les tests JUnit, vous devez référencer directement le ou les fichiers JAR bruts, bien que cela ne soit généralement pas nécessaire. JUnit 4, 5 et 6 proposent tous des fichiers JAR téléchargeables directement. Pour JUnit 5 et 6, vous devrez télécharger un fichier JAR volumineux (également appelé « uber jar ») comme décrit. ici.

Quels sont les composants d'un test JUnit ?

Maintenant que nous avons parlé un peu de la configuration de JUnit, passons à la construction et à l'exécution réelles de ces tests. Pour mieux illustrer la création de JUnits, nous allons commencer par quelque chose de basique. Dans l'exemple de test JUnit ci-dessous, nous avons une méthode simple (à gauche) qui convertit Fahrenheit en Celsius et un test JUnit (bien) écrit pour tester notre méthode. J'ai numéroté les parties clés du test JUnit et discuterai de chaque partie en détail ci-dessous.

 

Importations et dépendances dans JUnit

Les parties 1 et 2 de la capture d'écran ci-dessus correspondent aux importations des classes et méthodes JUnit utilisées par le test unitaire. Ces importations peuvent être spécifiées individuellement, mais on les spécifie généralement sous forme de packages entiers, indiqués par des astérisques. Les deux méthodes fonctionnent ; le niveau de détail des importations est une question de préférence.

Comment définir une classe de test JUnit

La partie 3 définit le début de notre classe de test. Il est important de noter ici la convention de nommage utilisée pour la classe, qui est : NomClasseTest. Cette convention de dénomination n'est pas obligatoire, mais c'est la manière la plus courante de nommer les classes JUnit, car le nom décrit succinctement l'objectif de la classe de test unitaire et la classe qu'elle teste.

Les annotations JUnit et leur utilisation

Dans la partie 4, nous découvrons notre première syntaxe spécifique à JUnit : l’annotation `@Test`. Les annotations sont essentielles lors de la création de tests JUnit. Elles permettent au framework JUnit d’identifier les éléments importants du test unitaire. Dans notre exemple, l’annotation `@Test` indique à JUnit que la méthode publique `void` à laquelle elle est associée peut être exécutée comme un cas de test.

Il existe de nombreuses autres annotations, mais voici quelques-unes des plus courantes pour JUnit 5 et 6.

• L'annotation `@BeforeEach` indique une méthode qui doit être exécutée avant chaque méthode de test de la classe. Elle sert généralement à mettre à jour ou à réinitialiser l'état nécessaire au bon déroulement des tests.
• L'annotation `@AfterEach` identifie une méthode qui doit être exécutée après chaque méthode de test de la classe. Elle peut servir à réinitialiser des variables, supprimer des fichiers temporaires, etc.
• @Disabled indique qu'une méthode de test ne doit pas être exécutée.
• @BeforeAll identifie une méthode qui doit être exécutée une fois avant toute autre méthode de test.
• @AfterAll identifie une méthode qui doit être exécutée une seule fois, après l'exécution de toutes les méthodes de test.

Nommage des méthodes de test dans JUnit

Pour la partie 5, notez à nouveau la convention d'appellation testMethodNametestMethodName, Où NomMéthode Le nom de la méthode testée dans la classe testée est indiqué. Cette convention d'appellation est courante, mais non obligatoire. Il arrive qu'une description supplémentaire soit ajoutée au nom pour décrire le comportement spécifique vérifié par le test.

La section « Données » et comment configurer un test

Dans la partie 6, le Donné section du test, nous construisons une nouvelle instance de la classe testée et l'initialisons comme il convient. Ceci est nécessaire car la méthode de test doit appeler la méthode testée pour la tester. Dans notre exemple, aucune autre initialisation n'est nécessaire au-delà de l'instanciation de la classe, mais dans de nombreux cas, une configuration supplémentaire peut être nécessaire, comme l'initialisation d'objets à transmettre au constructeur ou l'appel de méthodes qui configurent l'état de la classe testée.

La section « Quand » et comment invoquer la méthode testée

Dans la partie 7, le Lorsque vous La section du test comprend l'initialisation des variables qui doivent être transmises lors de l'appel de la méthode testée, puis de l'appel de la méthode de test (partie 8). Les variables doivent recevoir des valeurs significatives qui amènent le test à exercer les parties de la méthode de test qui nous intéressent. Notez que si une variable est un objet, elle peut être instanciée ou simulée.

Capturez la sortie de la méthode testée.

Dans la partie 8, si la méthode testée renvoie une valeur, celle-ci doit être capturée dans une variable afin que sa valeur puisse être vérifiée.

La section « Alors » et l’utilisation des assertions pour vérifier les résultats des tests

Les tests unitaires ne sont utiles que s'ils incluent des assertions qui vérifient que la méthode testée renvoie la valeur attendue et/ou modifie l'état des autres objets comme prévu. Sans assertions, comme expliqué dans la partie 9, aucune vérification n'est effectuée. Votre test n'est alors, au mieux, qu'un test de fumée qui ne fournit de retour d'information que lorsqu'une exception est levée.

Les méthodes d'assertion JUnit, incluses dans la classe `org.junit.jupiter.api.Assertions` dans JUnit 5 et 6, et dans la classe `org.junit.Assert` dans JUnit 4, servent généralement à déterminer la réussite ou l'échec des tests. Seules les assertions ayant échoué sont signalées par le framework JUnit. À l'instar des annotations, de nombreuses options d'assertion sont disponibles.

Dans notre exemple JUnit ci-dessus, nous utilisons la méthode assertEquals (expected, actual, delta). Le premier argument est :

• Le résultat attendu, que l'auteur du test définit.
• Le sortie réelle, qui est la valeur de retour de la méthode appelée
• Le delta, ce qui permet un écart acceptable entre les valeurs attendues et réelles. Ce delta est spécifique au fait que nous validons la valeur d'un type double.

Comment exécuter un JUnit

Choisissez votre propre aventure ! Ici, nous examinerons trois façons d'exécuter JUnits :

• Directement depuis la ligne de commande
• Depuis l'IDE (Eclipse et IntelliJ)
• Utilisation des systèmes de construction (Maven et Gradle)

Comment exécuter un JUnit à partir de l'EDI

Eclipse

Dans l'Explorateur de packages, localisez votre test JUnit. Cliquez avec le bouton droit et sélectionnez Exécuter en tant que > Test JUnit. Cela exécutera votre test et rapportera les résultats dans la vue JUnit Eclipse.

IntelliJ

L'exécution d'un test dans IntelliJ est similaire à Eclipse. Dans la fenêtre Projet, localisez votre test, cliquez avec le bouton droit de la souris et sélectionnez Exécuter 'testName'. Comme Eclipse, une fenêtre JUnit s'ouvrira avec les résultats du test.

Comment exécuter un test JUnit à partir des systèmes de construction Maven

Maven

Maven simplifie l'exécution des tests unitaires. Assurez-vous d'être au bon endroit dans votre console et que le fichier pom.xml de votre projet est correctement configuré. Vous pouvez ensuite exécuter la commande suivante pour lancer vos tests JUnit.

Pour exécuter l'intégralité de la suite de tests :

mvn test

Pour exécuter un ou plusieurs tests uniques/spécifiques :

mvn -D test=TestName test

Comment exécuter un test JUnit depuis le système de compilation Gradle

Gradle, tout comme Maven, a simplifié l'exécution des tests.

Pour exécuter l'intégralité de la suite de tests :

gradlew test

Pour exécuter un ou plusieurs tests uniques/spécifiques :

gradlew -D test.single=testName test

Remarque : Maven et Gradle sont leurs propres bêtes. Ce qui est montré ici est minimal pour couvrir les bases. Consultez leur documentation si vous voulez en savoir plus.

Comment exécuter un test JUnit depuis la ligne de commande

Pour exécuter une JUnit directement depuis la ligne de commande, vous avez besoin de quelques éléments :

• JDK sur votre chemin
• Le ou les fichiers JAR JUnit appropriés
• Les classes source et de test

La méthode la plus simple pour y parvenir dans JUnit 5 et 6 consiste à utiliser le lanceur de console JUnit comme suit.

java -jar /path/to/junit-platform-console-standalone-<version>.jar execute -cp /path/to/source/classes -cp /path/to/test/classes <test class name>

Remarque : l'exécution d'un test à partir de la ligne de commande est le plus souvent effectuée à partir d'un processus CI/CD s'exécutant dans un système de génération tel que Jenkins ou Azure DevOps.

Poursuivre les tests unitaires

Notre exemple a exécuté un test unitaire simple, et bien sûr, ce n'est que le début des tests unitaires. Les méthodes plus complexes à tester peuvent appeler des méthodes de classes dépendantes ou se connecter à des systèmes externes comme une base de données. Dans ce cas, il peut être judicieux d'isoler le code par simulation.

La moquerie aide à isoler les unités de code afin que nos tests unitaires puissent se concentrer uniquement sur la classe/méthode spécifique testée. Le framework le plus couramment utilisé pour se moquer dans les tests JUnit est Mockito.

Pour en savoir plus sur les moqueries, lisez le post de mon collègue : Comment automatiser un test unitaire Java, y compris les simulations et les assertions.

Si les tests unitaires sont si importants, pourquoi tout le monde ne les pratique-t-il pas systématiquement ? Malgré leur importance, les tests unitaires ne sont pas toujours faciles à mettre en œuvre ni à maintenir. Ils nécessitent une connaissance approfondie du développement et un effort constant pour maintenir les suites de tests à jour. Par conséquent, les tests unitaires sont souvent relégués au second plan, jusqu'à ce que des régressions surviennent.

Mais il ne doit pas en être ainsi.

Accélérez les tests JUnit avec l'IA

C'est ici que Parasoft Jtest Voici son assistant de tests unitaires basé sur l'IA, conçu pour simplifier l'écriture et la maintenance des tests unitaires. En quelques clics, les équipes qui débutent avec 0 % de tests unitaires peuvent les réaliser facilement. couverture de code peut générer automatiquement des suites de tests robustes couvrant 60 % ou plus de leur code Java. cabinet de services financiers a noté : « Depuis que nous avons implémenté Parasoft Jtest, nous avons réussi à réduire de plus de 50 % le temps nécessaire à la création et à la maintenance des tests unitaires. »

Voici comment votre équipe peut faire évoluer votre pratique de test.

• Générer automatiquement des cas de test JUnit pour le code précédemment découvert à l'aide de la création intelligente de tests en masse.
• Création de tests cibles pour le code modifié directement dans l'IDE ou au sein des flux de travail des demandes d'extraction.
• Gardez vos données en sécurité avec l'IA propriétaire de Parasoft, qui peut s'exécuter sur site : aucun code ni aucune donnée ne quitte votre environnement.
• Générer des mocks et des stubs pour isoler les dépendances et concentrer vos tests, ce qui permet de gagner du temps et d'éliminer le besoin d'écrire manuellement une logique de simulation.
• Personnaliser et étendre les tests avec des actions en un clic pour ajouter des assertions, paramétrer des cas de test et améliorer la maintenabilité.
• Accélérer l'exécution des tests en utilisant intégré analyse d'impact de test et tests unitaires en direct, qui identifie et exécute uniquement les tests nécessaires pour valider vos modifications de code récentes.

Si l'écriture et la maintenance des tests JUnit vous semblent fastidieuses, il est temps de moderniser votre approche. Des solutions de test optimisées par l'IA comme celle-ci peuvent transformer la création de tests, autrefois un goulot d'étranglement, en un avantage stratégique, vous permettant ainsi de consacrer plus de temps à la création de logiciels performants.