1. Le Problème : Le Chaos des Projets Complexes
Quand on débute, on travaille sur des projets de quelques fichiers. Mais les applications réelles sont bien plus complexes :
Le Problème des Bibliothèques Externes
Et si vous voulez utiliser une bibliothèque externe pour manipuler du JSON ou vous connecter à une base de données ? La méthode manuelle (télécharger des fichiers .jar, les ajouter au projet) est un cauchemar :
- Comment gérer les versions ?
- Comment gérer les dépendances de vos dépendances ?
- Que faire quand deux bibliothèques ont besoin de versions différentes d'une même dépendance ?
Le Problème de la Confiance
Vous écrivez une nouvelle fonctionnalité. Comment être sûr qu'elle fonctionne ? Et plus important, comment être sûr que votre modification n'a pas cassé une autre partie du programme qui fonctionnait très bien avant ? Tester tout à la main à chaque changement est impossible.
Les Solutions Professionnelles
Maven et JUnit sont les solutions à ces deux problèmes fondamentaux.
2. Maven : Le Chef d'Orchestre de Votre Projet
Maven est un outil de gestion de build et de dépendances. Il automatise toutes les tâches répétitives liées à la construction d'un projet.
Gestion des Dépendances : Votre Assistant Personnel
Analogie : Faire les Courses
Imaginez que Maven est votre assistant personnel pour faire les courses. Au lieu d'aller vous-même au supermarché (télécharger des .jar), vous lui donnez une liste de courses (le fichier pom.xml). Maven va alors :
- Se connecter à un immense entrepôt en ligne (le Maven Central Repository)
- Trouver les produits exacts à la bonne version
- Vérifier la recette de ces produits et aller chercher tous les ingrédients dont eux-mêmes ont besoin
- Ramener le tout et l'organiser proprement dans votre projet
Le Fichier pom.xml : Le Cœur de Votre Projet
Chaque projet Maven est défini par un fichier pom.xml (Project Object Model). C'est sa carte d'identité et sa liste de configuration.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>fr.moncours.java</groupId>
<artifactId>mon-projet-demo</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.10.2</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
La Structure Standard d'un Projet Maven
Maven impose une structure de dossiers standard. C'est le principe de "convention plutôt que configuration".
mon-projet-demo/
├── pom.xml
└── src/
├── main/
│ └── java/
│ └── fr/moncours/java/ ← Code source
└── test/
└── java/
└── fr/moncours/java/ ← Code de test
Convention Maven
Maven s'attend à trouver votre code source dans src/main/java et vos tests dans src/test/java. C'est comme une "recette" que Maven connaît par cœur.
3. JUnit : Votre Filet de Sécurité
JUnit est un framework pour écrire et exécuter des tests unitaires automatisés. Un test unitaire est un petit morceau de code qui vérifie qu'une "unité" de votre code (généralement une méthode) se comporte exactement comme prévu.
Pourquoi Tester ?
→ Confiance
Les tests prouvent que votre code fonctionne.
→ Non-régression
En rejouant tous vos tests après chaque modification, vous êtes immédiatement alerté si vous avez cassé quelque chose. C'est un filet de sécurité indispensable.
→ Documentation Vivante
Les tests montrent comment vos méthodes sont censées être utilisées.
L'Anatomie d'un Test JUnit
Pour écrire un test, on suit une structure simple et une convention de nommage :
1. Créer une classe de test
Si vous avez une classe Calculateur.java, votre classe de test s'appellera CalculateurTest.java et sera placée dans le dossier src/test/java.
2. Utiliser l'annotation @Test
Cette "étiquette" magique indique à JUnit que la méthode qui suit est un test et qu'il doit l'exécuter.
3. Suivre le pattern AAA
- Arrange (Arranger) : Préparez tout le nécessaire. Créez les objets, définissez les entrées.
- Act (Agir) : Exécutez la méthode que vous voulez tester.
- Assert (Vérifier) : Comparez le résultat obtenu avec le résultat attendu.
Exemple Complet : Tester un Calculateur
1. Le code à tester (src/main/java/.../Calculateur.java)
public class Calculateur {
public int additionner(int a, int b) {
return a + b;
}
}
2. Le code de test (src/test/java/.../CalculateurTest.java)
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
class CalculateurTest {
@Test
void testAdditionNombresPositifs() {
// 1. Arrange
Calculateur calc = new Calculateur();
int a = 5;
int b = 3;
int resultatAttendu = 8;
// 2. Act
int resultatReel = calc.additionner(a, b);
// 3. Assert
assertEquals(resultatAttendu, resultatReel,
"L'addition de 5 et 3 devrait être 8");
}
@Test
void testAdditionAvecUnNegatif() {
// Arrange
Calculateur calc = new Calculateur();
// Act
int resultatReel = calc.additionner(-5, 3);
// Assert
assertEquals(-2, resultatReel,
"L'addition de -5 et 3 devrait être -2");
}
}
Exécuter les Tests
Lorsque vous exécutez ces tests (généralement via un bouton "Play" dans votre IDE), JUnit vous affichera :
- Une barre verte si tous les tests passent
- Une barre rouge si au moins une des affirmations (assertEquals) échoue
- Un message d'erreur précis indiquant quel test a échoué et pourquoi