Informatique · Java

Maven et JUnit

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 quiz

Le problème

Un projet Java compte des dizaines de fichiers et de bibliothèques. À chaque modification, il faut tout reconstruire et relancer les tests.

code tests pom.xml mvncompile, test, package

Maven refait tout cela d'une seule commande.

Après cette fiche, tu sais

  • organiser un projet selon la structure standard de Maven et lire un pom.xml ;
  • déclarer une dépendance avec le bon scope ;
  • dire ce que font mvn test, mvn package, mvn install et mvn clean ;
  • écrire des tests JUnit avec les annotations et les assertions de l'API Jupiter ;
  • éviter les pièges : ordre des arguments, nombres à virgule, JUnit 4 contre Jupiter, délais.
Question à garder en tête : un test qui passe toujours, même quand le code est faux, sert-il à quelque chose ?

Non, il ne prouve rien, je crois ?

Bonne intuition. La réponse arrive après le Bug Buster, avec un exemple.

Un build qui se rejoue

Notion 1 · Le projet

La convention plutôt que la configuration

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.

src/main/javale code src/test/javales tests target/créé par Maven Maven compile et empaquette : le résultat va dans target/

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

groupIdch.mukbang artifactIdcalculatrice version1.0-SNAPSHOT ch.mukbang:calculatrice:1.0-SNAPSHOT

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.

1.0-SNAPSHOTpeut changer 1.0publiée, figée 1.0.1correction Une version publiée ne se modifie jamais.
Structure standard d'un projetdossiers
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
pom.xmlxml
<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>

Ce que produit chaque phase

Fais défiler : le dossier du projet se remplit à chaque phase de mvn install, puis mvn clean fait place nette.

$ mvn install avant le build calculatrice/ ├─ pom.xml ├─ src/main/java/…/Calculatrice.java ├─ src/test/java/…/CalculatriceTest.java └─ target/ ├─ classes/…/Calculatrice.class ├─ test-classes/…/CalculatriceTest.class ├─ surefire-reports/ : 7 tests, 0 échec └─ calculatrice-1.0-SNAPSHOT.jar ~/.m2/repository/ch/mukbang/calculatrice/ └─ 1.0-SNAPSHOT/…-1.0-SNAPSHOT.jar en vert : ce que la phase vient de créer
Étape 1 sur 7 · avant le build

Le projet ne contient que le pom.xml et les sources. target/ n'existe pas encore.

Étape 2 sur 7 · validate

Maven lit le pom.xml et vérifie que le projet est correct et complet. Aucun fichier n'est produit.

Étape 3 sur 7 · compile

Le compilateur traduit src/main/java en bytecode : Calculatrice.class apparaît dans target/classes.

Étape 4 sur 7 · test

Les tests sont compilés, puis Surefire les lance : 7 tests, 0 échec. Un seul échec arrêterait le build ici.

Étape 5 sur 7 · package

Le code de l'application, sans les tests, est empaqueté dans calculatrice-1.0-SNAPSHOT.jar.

Étape 6 sur 7 · verify, install

verify n'a rien à faire ici ; install copie le .jar dans ~/.m2/repository, pour tes autres projets.

Étape 7 sur 7 · mvn clean

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

Des phases dans un ordre fixe

Maven connaît trois cycles de vie : default (construire et livrer), clean (nettoyer) et site (documentation).1

default clean site construire, livrer nettoyer documentation

Le cycle default enchaîne ses phases dans un ordre fixe. Demander une phase exécute toutes celles qui la précèdent.

validate compile test package verify install ← demandée deploy : pas exécutée mvn install lance les cinq phases avant elle.

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.

compile test package compiler:compile surefire:test jar:jar

mvn test

Compile, 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 package

Supprime target/ avant de reconstruire. -DskipTests saute les tests : à éviter par habitude.

Le cycle default, phase par phase

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.

Scène 1 · Le cycle de vie default

mvn validate

Tu as vu ? 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

Déclarer une bibliothèque, choisir son scope

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

pom.xmldéclare Maven Centraltélécharge ~/.m2/repositorydépôt local Les bibliothèques qu'elle utilise suivent automatiquement.

Elle embarque aussi les bibliothèques dont elle a besoin : ce sont les dépendances transitives.

ton projet bibliothèque JSON dépendance transitive

Qui lance les tests ?

Le plugin Surefire lance les tests JUnit pendant la phase test.6

mvn testcommande phase testcompile surefireplugin testsJUnit

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

Maven 3.9 Java 21 JUnit 6.1.3 Surefire 3.6.0 7 tests, 0 échec
Une dépendance réservée aux testsxml
<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>

compile (défaut)

Compiler, tester, exécuter ; transmis aux projets qui dépendent du tien. Exemple : une bibliothèque JSON.

test

Seulement compiler et lancer les tests ; non transmis. Exemple : JUnit, Mockito.

provided

Compiler et tester ; fourni à l'exécution par le JDK ou le serveur. Exemple : l'API Servlet.

runtime

Exécuter et tester, mais pas compiler. Exemple : un pilote JDBC.

Exercice · à toi

Quel scope ?

Range chaque bibliothèque dans le scope qu'il lui faut.

Le test, un garde-fou

Notion 4 · JUnit

Écrire un test unitaire

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

JUnit 5API Jupiter JUnit 6API Jupiter mêmes @Test, @BeforeEach, assertEquals

Préparer (arrange)

Crée l'objet à tester, ici une Calculatrice neuve, dans une méthode @BeforeEach.

Agir (act)

Appelle la méthode à tester : calc.additionner(2, 3).

Vérifier (assert)

Compare le résultat attendu au résultat réel avec une assertion.

Les annotations Jupiter

@Test

Marque une méthode de test. En JUnit 4 : même nom, mais du paquet org.junit.

@BeforeEach · @AfterEach

Avant et après chaque test. En JUnit 4 : @Before et @After.

@BeforeAll · @AfterAll

Une fois avant et après tous les tests ; méthode static par défaut. En JUnit 4 : @BeforeClass et @AfterClass.

@DisplayName

Nom lisible dans le rapport. Pas d'équivalent en JUnit 4.

@Disabled

Désactive un test sans le supprimer. En JUnit 4 : @Ignore.

@ParameterizedTest

Le même test avec plusieurs jeux de données. Autre mécanisme en JUnit 4.

CalculatriceTest.java (extrait)java
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).4
  • assertTrue 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.
attendu4.5 réelmoyenne() tolérance1e-9 Ordre : attendu, réel, puis tolérance.

Exception attendue

assertThrows(Type.class, () -> …) : le code doit lever cette exception. L'assertion la renvoie pour qu'on examine son message.

diviser(10, 0)le code ArithmeticExceptionlevée ? oui Sinon, le test échoue.

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.

assertTimeoutPreemptively 100 ms, coupé assertTimeout boucle infinie : la fin n'arrive jamais

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

static @BeforeAll : une fois instance 1test 1 instance 2test 2 instance 3test 3

La barre verte

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é.

Scène 2 · La barre verte

Prêt à lancer mvn test

CalculatriceTest Tests : 0/4 · Échecs : 0

Un seul test rouge suffit : BUILD FAILURE, et Maven ne passe pas à package. Répare le code, la barre redevient verte.

Démasque le bug

Jeu · Bug Buster

Choisis le test qui démasque le bug

Cinq méthodes cachent un défaut. Pour chacune, choisis l'assertion JUnit qui le met en évidence. Chaque réponse est expliquée.

return a − b; // défaut assertEquals(5, calc.additionner(2, 3)) le test échoue : le défaut apparaît
Bug Buster

Cinq défauts à démasquer

Lis la méthode, puis choisis le test.

Réponse à ma question : non. Un bon test échoue quand le code est faux, et passe quand il est juste.

Et assertNotNull sur un int ?

Il passe toujours : un int n'est jamais null. Il ne prouve rien.

Les pièges à éviter

Attention

Les pièges classiques

Six erreurs reviennent sans cesse. Aucune ne fait planter le build : elles passent sans bruit, et c'est bien là le danger.

code fauxa − b test vertassertNotNull(int) Un test qui passe toujours ne prouve rien.
Inverser les arguments d'assertEquals

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.

Comparer des double sans tolérance

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).

Mélanger JUnit 4 et Jupiter

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.

Mal nommer la classe de test

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 sur une boucle infinie

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.

Oublier <scope>test</scope>

Sans scope, JUnit passe en compile : il est embarqué avec l'application et transmis aux projets qui en dépendent.

Entraîne-toi

Exercices corrigés

Cherche d'abord, puis ouvre le corrigé.

1Tu tapes 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.

2Écris la dépendance JUnit Jupiter 6.1.3, réservée aux tests.Voir le corrigé
<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.

3Teste 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.

4Trouve le défaut de chaque ligne : (a) 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

La fiche en huit lignes

Du projet au dépôt local, dans l'ordre des phases.

POMdécrit mvn testtests JUnit mvn installdépôt local Chaque phase exécute celles qui la précèdent.
Structuresrc/main/java, src/test/java, pom.xml ; Maven produit tout dans target/.
POMcoordonnées GAV (groupId, artifactId, version), propriétés, dépendances, plugins.
Cycle defaultvalidate, compile, test, package, verify, install, deploy : chaque phase exécute les précédentes.
DépôtsMaven Central → dépôt local ~/.m2/repository ; install y copie ton .jar.
Scopescompile (défaut), test (JUnit), provided (fourni par le serveur), runtime.
JUnit 6API Jupiter : @Test, @BeforeEach, @BeforeAll (static), @DisplayName, @Disabled, @ParameterizedTest.
AssertionsassertEquals(attendu, réel[, tolérance]), assertThrows, assertAll, assertTimeoutPreemptively.
Surefirelance les classes *Test, Test*, *Tests, *TestCase ; un échec arrête le build.

Seize questions pour finir

Dernière étape, le quiz. Pense à la règle d'or du cycle de vie : demander une phase, c'est demander toutes celles d'avant.
Quiz final

Teste-toi

Sources

  1. Apache Maven Project, Introduction to the Build Lifecycle (cycles default, clean, site ; phases et goals), consulté le 8 octobre 2026. maven.apache.org
  2. Apache Maven Project, Introduction to the Dependency Mechanism (scopes, dépendances transitives), Introduction to Repositories (téléchargement depuis le dépôt central par défaut, dépôt local) et Configuring Maven (dépôt local ${user.home}/.m2/repository par défaut), consulté le 8 octobre 2026. dépendances, dépôts, configuration (maven.apache.org)
  3. Apache Maven Surefire, Inclusions and Exclusions of Tests (noms de classes lancés par défaut), consulté le 8 octobre 2026. maven.apache.org
  4. JUnit team, JUnit User Guide 6.1.3, pages Annotations, Assertions et Test Instance Lifecycle, et Assertions (JUnit 6.1.3 API) (assertEquals avec une tolérance delta), consulté le 8 octobre 2026. docs.junit.org (annotations) · docs.junit.org (assertions) · docs.junit.org (cycle de vie) · docs.junit.org (Javadoc Assertions)
  5. JUnit team, Release Notes (JUnit 6.0.0 du 30 septembre 2025, Java 17 minimum ; 6.1.3 du 7 août 2026), consulté le 8 octobre 2026. docs.junit.org
  6. Apache Maven Surefire, Using JUnit 5 Platform (lancer des tests Jupiter avec Surefire), consulté le 8 octobre 2026. maven.apache.org
  7. Apache Maven Project, Introduction to the POM (coordonnées GAV, structure du pom.xml), consulté le 8 octobre 2026. maven.apache.org
  8. Apache Maven Project, Introduction to the Standard Directory Layout (src/main/java, src/test/java, target/), consulté le 8 octobre 2026. 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.

Glisser pour continuer vers JDBC et JPA
Université