mvn test
Compile, puis lance les tests unitaires.
Informatique · Java
Maven automatise la construction d'un projet Java ; JUnit vérifie, test après test, que le code fait ce qu'il promet.
Déjà à l'aise ? Aller au quizLe problème
Un projet Java compte des dizaines de fichiers et de bibliothèques. À chaque modification, il faut tout reconstruire et relancer les tests.
Maven refait tout cela d'une seule commande.
Après cette fiche, tu sais
pom.xml ;mvn test, mvn package, mvn install et mvn clean ;Le plan
Non, il ne prouve rien, je crois ?
Un build qui se rejoue
Notion 1 · Le projet
Maven est un outil de construction (build) pour Java : il compile, lance les tests, empaquette le programme et télécharge les bibliothèques dont il dépend.
Maven suppose une structure standard : si tu ranges les fichiers là où il les attend, il n'a presque rien à configurer.8
Le POM (Project Object Model, fichier pom.xml) décrit le projet.7
Ces trois coordonnées sont les coordonnées GAV : elles identifient le projet de façon unique.
SNAPSHOT ou version publiée ?
Le suffixe -SNAPSHOT signale une version en développement, qui peut encore changer. Une version publiée (1.0) ne change plus jamais : pour corriger, on publie 1.0.1.
calculatrice/ ├── pom.xml la description du projet ├── src/main/java/ le code de l'application │ └── ch/mukbang/calc/Calculatrice.java ├── src/main/resources/ fichiers de configuration, images… ├── src/test/java/ les tests (jamais livrés) │ └── ch/mukbang/calc/CalculatriceTest.java └── target/ créé par Maven : classes, rapports, .jar
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>ch.mukbang</groupId>
<artifactId>calculatrice</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<properties>
<maven.compiler.release>21</maven.compiler.release>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
</project>Fais défiler : le dossier du projet se remplit à chaque phase de mvn install, puis mvn clean fait place nette.
Le projet ne contient que le pom.xml et les sources. target/ n'existe pas encore.
Maven lit le pom.xml et vérifie que le projet est correct et complet. Aucun fichier n'est produit.
Le compilateur traduit src/main/java en bytecode : Calculatrice.class apparaît dans target/classes.
Les tests sont compilés, puis Surefire les lance : 7 tests, 0 échec. Un seul échec arrêterait le build ici.
Le code de l'application, sans les tests, est empaqueté dans calculatrice-1.0-SNAPSHOT.jar.
verify n'a rien à faire ici ; install copie le .jar dans ~/.m2/repository, pour tes autres projets.
Un autre cycle de vie : il supprime target/. Le .jar installé dans ~/.m2 reste.
Des phases dans l'ordre
Notion 2 · Le cycle de vie
Maven connaît trois cycles de vie : default (construire et livrer), clean (nettoyer) et site (documentation).1
Le cycle default enchaîne ses phases dans un ordre fixe. Demander une phase exécute toutes celles qui la précèdent.
Phase demandée = toutes les phases avant elle, dans l'ordre.
Des goals
Chaque phase déclenche des goals de plugins : compile appelle compiler:compile, test appelle surefire:test, package appelle jar:jar.
mvn testCompile, puis lance les tests unitaires.
mvn package… puis crée le .jar dans target/.
mvn install… puis copie le .jar dans le dépôt local ~/.m2/repository.
mvn clean packageSupprime target/ avant de reconstruire. -DskipTests saute les tests : à éviter par habitude.
Fais défiler : chaque phase demandée entraîne les précédentes. Le terminal montre les goals déclenchés (sortie simplifiée de Maven 3.9 pour un projet en .jar). Tu peux aussi toucher une phase.
mvn validate
mvn install ne saute rien : validate, compile, test, package, verify, puis install. Un test rouge en chemin, et tout s'arrête avant le .jar.Une bibliothèque, un scope
Notion 3 · Les dépendances
Pour utiliser une bibliothèque, tu la déclares dans le POM avec ses coordonnées GAV. Maven la télécharge depuis Maven Central et la range dans le dépôt local ~/.m2/repository.2
Elle embarque aussi les bibliothèques dont elle a besoin : ce sont les dépendances transitives.
Qui lance les tests ?
Le plugin Surefire lance les tests JUnit pendant la phase test.6
Un build reproductible
Le projet de cette fiche a été construit avec Maven 3.9, Java 21, JUnit 6.1.3 et Surefire 3.6.0 : ses 7 tests passent.5
<dependencies>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>6.1.3</version>
<scope>test</scope> <!-- seulement pour les tests -->
</dependency>
</dependencies>Compiler, tester, exécuter ; transmis aux projets qui dépendent du tien. Exemple : une bibliothèque JSON.
Seulement compiler et lancer les tests ; non transmis. Exemple : JUnit, Mockito.
Compiler et tester ; fourni à l'exécution par le JDK ou le serveur. Exemple : l'API Servlet.
Exécuter et tester, mais pas compiler. Exemple : un pilote JDBC.
Range chaque bibliothèque dans le scope qu'il lui faut.
Le test, un garde-fou
Notion 4 · JUnit
JUnit est le framework de tests unitaires de référence en Java. Sa version actuelle, JUnit 6 (sortie le 30 septembre 2025, Java 17 minimum), garde le modèle Jupiter de JUnit 5 : mêmes annotations, mêmes assertions, dans org.junit.jupiter.api.5
Crée l'objet à tester, ici une Calculatrice neuve, dans une méthode @BeforeEach.
Appelle la méthode à tester : calc.additionner(2, 3).
Compare le résultat attendu au résultat réel avec une assertion.
Marque une méthode de test. En JUnit 4 : même nom, mais du paquet org.junit.
Avant et après chaque test. En JUnit 4 : @Before et @After.
Une fois avant et après tous les tests ; méthode static par défaut. En JUnit 4 : @BeforeClass et @AfterClass.
Nom lisible dans le rapport. Pas d'équivalent en JUnit 4.
Désactive un test sans le supprimer. En JUnit 4 : @Ignore.
Le même test avec plusieurs jeux de données. Autre mécanisme en JUnit 4.
import static org.junit.jupiter.api.Assertions.*;
class CalculatriceTest {
private Calculatrice calc;
@BeforeEach
void creerCalculatrice() {
calc = new Calculatrice(); // neuve avant chaque test
}
@Test
@DisplayName("2 + 3 donne 5")
void additionne() {
assertEquals(5, calc.additionner(2, 3)); // attendu, puis réel
}
@Test
void divisionParZero() {
ArithmeticException e = assertThrows(ArithmeticException.class,
() -> calc.diviser(10, 0));
assertEquals("/ by zero", e.getMessage());
}
@Test
void moyenneDeTroisNotes() {
assertEquals(4.5, calc.moyenne(List.of(4.0, 5.0, 4.5)), 1e-9);
}
@ParameterizedTest
@CsvSource({ "1, 1, 2", "2, 3, 5", "-4, 4, 0" })
void additionsVariees(int a, int b, int attendu) {
assertEquals(attendu, calc.additionner(a, b));
}
}Extrait : les autres import (Test, BeforeEach, DisplayName, ParameterizedTest, CsvSource, List) sont omis. Avec le test d'une liste vide, la classe complète compte 7 exécutions.
Les assertions essentielles
assertEquals(attendu, réel) : égalité ; pour un double, ajoute une tolérance : assertEquals(4.5, x, 1e-9).4assertTrue et assertFalse, assertNull et assertNotNull.assertSame vérifie qu'il s'agit du même objet (même référence), pas seulement d'un objet égal.Exception attendue
assertThrows(Type.class, () -> …) : le code doit lever cette exception. L'assertion la renvoie pour qu'on examine son message.
Plusieurs vérifications
assertAll(…) regroupe plusieurs vérifications et signale tous les échecs, pas seulement le premier.
Le délai
assertTimeoutPreemptively(durée, () -> …) interrompt le code s'il dépasse la durée. assertTimeout, lui, attend la fin du code avant de comparer.
Pourquoi @BeforeAll est-il static ?
Par défaut, JUnit crée une nouvelle instance de la classe pour chaque test. Une méthode lancée une seule fois ne peut donc pas dépendre d'une instance, sauf avec @TestInstance(Lifecycle.PER_CLASS).4
Fais défiler : mvn test lance quatre tests, un par un. Les pastilles cassent ou réparent le code testé ; au départ, diviser est bogué.
Prêt à lancer mvn test
Démasque le bug
Jeu · Bug Buster
Cinq méthodes cachent un défaut. Pour chacune, choisis l'assertion JUnit qui le met en évidence. Chaque réponse est expliquée.
Lis la méthode, puis choisis le test.
Et assertNotNull sur un int ?
int n'est jamais null. Il ne prouve rien.Les pièges à éviter
Attention
Six erreurs reviennent sans cesse. Aucune ne fait planter le build : elles passent sans bruit, et c'est bien là le danger.
assertEquals(calc.additionner(2, 3), 5) compile et passe, mais en cas d'échec le message ment : il annonce la valeur calculée comme « attendue ». L'ordre est toujours attendu, puis réel.
En double, 0.1 + 0.2 vaut 0.30000000000000004 : assertEquals(0.3, 0.1 + 0.2) échoue. Écris assertEquals(0.3, 0.1 + 0.2, 1e-9).
Une méthode annotée org.junit.Test (JUnit 4) n'est pas exécutée par le moteur Jupiter, et @BeforeEach n'agit que sur les tests Jupiter. Importe tout depuis org.junit.jupiter.api.
Par défaut, Surefire ne lance que les classes nommées Test*, *Test, *Tests ou *TestCase.3 Une classe VerifCalculatrice serait ignorée sans bruit.
assertTimeout attend la fin du code avant de comparer la durée : le test ne se termine jamais. Seul assertTimeoutPreemptively interrompt le code et échoue à temps.
Sans scope, JUnit passe en compile : il est embarqué avec l'application et transmis aux projets qui en dépendent.
Cherche d'abord, puis ouvre le corrigé.
mvn package. Quelles phases s'exécutent ? Le .jar est-il ensuite disponible pour tes autres projets ?Voir le corrigévalidate, compile, test, package (avec les phases intermédiaires comme test-compile). Le .jar est créé dans target/, mais il n'est pas dans le dépôt local : il faut mvn install pour que tes autres projets puissent le déclarer comme dépendance.
<dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter</artifactId> <version>6.1.3</version> <scope>test</scope> </dependency>
Le <scope>test</scope> fait que JUnit ne sert qu'à compiler et lancer les tests.
moyenne(List.of(4.0, 5.0, 4.5)), puis le cas d'une liste vide, qui doit lever une IllegalArgumentException.Voir le corrigéassertEquals(4.5, calc.moyenne(List.of(4.0, 5.0, 4.5)), 1e-9); assertThrows(IllegalArgumentException.class, () -> calc.moyenne(List.of()));
La moyenne vaut 13,5 ÷ 3 = 4,5, avec une tolérance car c'est un double. Ces deux tests font partie du projet de la fiche et passent.
assertEquals(calc.additionner(2, 3), 5); (b) assertEquals(0.3, 0.1 + 0.2); (c) @BeforeAll void init() { … }Voir le corrigé(a) Arguments inversés : le test fonctionne, mais le message d'échec est trompeur. (b) Pas de tolérance : échoue, car 0.1 + 0.2 ≠ 0.3 en double. (c) Une méthode @BeforeAll doit être static (sauf avec @TestInstance(Lifecycle.PER_CLASS)), sinon JUnit signale une erreur.
Tout en huit lignes
À retenir
Du projet au dépôt local, dans l'ordre des phases.
Seize questions pour finir
${user.home}/.m2/repository par défaut), consulté le 8 octobre 2026. dépendances, dépôts, configuration (maven.apache.org)Fiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026. Code des exemples compilé et testé avec Maven 3.9, Java 21, JUnit 6.1.3 et Surefire 3.6.0.