
Le premier ticket de Samuel Okafor vous attend dans l’outil de suivi de l’équipe :
Leïla Haddad, en CDD depuis sept mois, voit un solde de 6,64 jours dans Hamac. Elle a demandé 5 jours de congés, et l’application a refusé sa demande quand son manager, Karim Benali, a voulu l’approuver. Elle ne comprend pas pourquoi Hamac affiche un solde qu’elle ne peut pas utiliser. Pour être honnête, moi non plus.
Inès vous transmet le ticket avec une consigne qui peut surprendre :
Ne corrige rien tout de suite. Je veux d’abord comprendre pourquoi c’est arrivé, et savoir si ça peut se reproduire quand on ajoutera les stages.
Cette prudence est celle de toute équipe qui reprend un code qu’elle ne connaît pas. Dans une application comme Hamac, trouver la ligne fautive prend parfois dix minutes. Mais si vous ne comprenez pas comment ce bug a pu apparaître, vous ne pouvez pas garantir qu’il ne reviendra pas, ni que votre correction n’en crée pas un autre ailleurs.
Pourquoi commencer par reproduire le bug ?
Un ticket décrit ce que l’utilisateur a vu, pas ce que le code a fait. Samuel sait que la demande de Leïla a été refusée, mais il ne sait pas quelle partie de l’application a pris cette décision, ni avec quelles valeurs. Tant que vous n’avez pas observé le problème vous-même, vous travaillez sur une hypothèse.
Reproduire le bug a deux autres avantages. Vous connaîtrez les données exactes qui le déclenchent. Et vous disposerez d’un moyen simple de vérifier, plus tard, que votre correction fonctionne : il suffira de rejouer le même scénario.
Avant toute observation, relancez les tests depuis la racine du projet :
./mvnw testIls doivent se terminer parBUILD SUCCESS, comme au chapitre précédent. C’est votre point de référence : tant qu’ils passent, le comportement qu’ils vérifient n’a pas changé. Lancez ensuite l’application :
./mvnw spring-boot:runSous Windows, remplacez toujours./mvnwparmvnw.cmd. Après quelques secondes, la console affiche une ligne qui commence parStarted HamacApplication: l’application écoute surhttp://localhost:8080.
Les pages web sont servies par la même application, mais elles fonctionnent encore avec des données simulées : elles ne vous apprendraient rien sur le comportement réel de Hamac. Vous allez donc interroger l’API directement aveccurl, comme le feront ces pages une fois branchées.
Dans un second terminal, consultez le solde de Leïla Haddad, la salariée n° 4 :
curl "http://localhost:8080/api/leave/balance?employeeId=4"L’API renvoie un solde d’environ 6,64 jours, le chiffre que Leïla a vu à l’écran. Une demande de 5 jours ouvrés, la n° 7, attend justement l’approbation de Karim. Approuvez-la à sa place :
curl "http://localhost:8080/api/leave/approve?id=7"L’API répondRefused: insufficient balance. Le bug est reproduit : l’application affiche un solde suffisant, puis refuse la demande au nom d’un solde insuffisant.
Vous avez peut-être tiqué en lançant cette seconde commande : une simple requêteGET, celle qu’un navigateur envoie pour afficher une page, suffit à modifier une demande de congés. Ce n’est pas le comportement attendu d’une API, et vous le corrigerez au chapitre 5. Pour l’instant, restez concentré sur le ticket : un diagnostic qui essaie de tout traiter en même temps finit par ne rien traiter.
Les tests passent pourtant tous. Pourquoi ne détectent-ils pas ce bug ?
Ils vérifient le parcours principal avec un salarié en CDI. Or les droits d’un CDI ne dépendent pas de sa date d’entrée : le calcul qui pose problème n’est jamais exécuté. Un test qui passe garantit que le comportement testé n’a pas changé. Il ne garantit pas que l’application est correcte dans les cas que personne n’a pensé à tester.
Ouvrezsrc/test/java/com/hamac/LeaveApprovalTests.javapour le constater. Voici le test qui vérifie l’approbation :
@Test
void approvesRequestOfPermanentEmployee() {
assertThat(mvc.get().uri("/api/leave/approve?id=1"))
.hasStatusOk()
.bodyText().isEqualTo("Approved");
}L’objetmvcest unMockMvcTester, fourni par Spring : il envoie une requête HTTP à l’application sans démarrer de vrai serveur, puis vous permet de vérifier la réponse. Vous n’avez pas à écrire de tels tests dans ce chapitre, mais vous les lirez souvent. Celui-ci approuve la demande n° 1, déposée par un salarié en CDI : aucun test ne passe par la branche des CDD.
Vous savez maintenant ce qui se passe. Reste à comprendre où la décision est prise. La route appelée,/api/leave/approve, vous mène au contrôleur des congés. Ouvrezsrc/main/java/com/hamac/controller/LeaveController.java: toute l’approbation se trouve dans une seule méthode.
@GetMapping("/approve")
public String approve(@RequestParam long id) {
var req = leaveRequestRepository.findAll().stream()
.filter(r -> r.getId() == id)
.findFirst()
.orElse(null);
var e = employeeRepository.findById(req.getEmployeeId()).orElse(null);
double d;
if (e.getContractType().equals("CDI")) {
d = 25;
} else if (e.getContractType().equals("CDD")) {
long m = ChronoUnit.DAYS.between(e.getHireDate(), LocalDate.now()) / 30;
d = m * 2.08;
} else if (e.getContractType().equals("Alternance")) {
d = 30;
} else {
d = 0;
}
if (d - e.getDaysTaken() < req.getWorkingDays()) {
req.setStatus("REFUSED");
leaveRequestRepository.save(req);
return "Refused: insufficient balance";
}
req.setStatus("APPROVED");
e.setDaysTaken(e.getDaysTaken() + req.getWorkingDays());
leaveRequestRepository.save(req);
employeeRepository.save(e);
new NotificationService().notify(e, "Votre demande de congés est approuvée.");
return "Approved";
}Lisez-la comme vous suivriez la demande de Leïla de bout en bout. La méthode :
recherche la demande et le salarié concerné ;
calcule les droits du salarié selon son type de contrat ;
compare le solde au nombre de jours demandés ;
met à jour la demande et le salarié, puis les enregistre ;
crée un service de notification et envoie un message ;
construit la réponse HTTP.
Six étapes, et aucune ne porte de nom. Pour savoir ce que fait la méthode, il faut lire chaque ligne et reconstituer soi-même son découpage, comme vous venez de le faire. C’est un premier indice : un code qui oblige à cette reconstitution est un code que chaque nouvel arrivant devra relire en entier avant d’oser le modifier.
Pour le ticket, c’est l’étape 2 qui compte. Le refus dépend du calcul des droits : pour Leïla, en CDD, il compte les mois écoulés depuis son entrée et les multiplie par 2,08. Gardez ce calcul en tête, car vous l’avez déjà déclenché une première fois : la consultation du solde, que vous avez appelée juste avant, doit elle aussi calculer les droits de Leïla pour afficher 6,64 jours.
À ce stade, la tentation est grande de chercher la différence entre les deux calculs, de la corriger et de fermer le ticket. Le réflexe le plus risqué consiste justement à s’arrêter là. Le symptôme disparaîtrait, mais tout ce qui l’a rendu possible resterait en place, prêt à produire le prochain.
Relisez plutôtapproveavec les quatre critères du rappel, en vous posant pour chacun une question concrète :
Critère | La question à vous poser | Ce que vous observez dans |
Responsabilité unique | Pour combien de raisons différentes faudra-t-il modifier cette méthode ? | Au moins quatre : la règle RH, le stockage, les notifications, le format de l’API. |
DRY | Cette règle existe-t-elle ailleurs ? | Le calcul des droits est aussi écrit dans la méthode qui affiche le solde. |
Couplage | Peut-on exécuter cette logique sans ses collaborateurs réels ? | Non : le service de notification est créé avec |
Cohésion | Les lignes de la méthode servent-elles un même objectif ? | Non : accès aux données, règles RH, notification et HTTP s’y côtoient. |
Imaginez les demandes que l’équipe recevra dans les prochains mois. Samuel voudra faire évoluer une règle RH. Inès décidera peut-être de changer la façon dont les données sont stockées. L’équipe infrastructure remplacera un jour le système d’envoi des notifications. Et les pages web, une fois branchées, auront besoin de réponses dans un format différent.
Ces quatre demandes viennent de personnes différentes, pour des raisons sans rapport entre elles. Pourtant, elles aboutiront toutes dans la même méthode. Chaque modification fera donc courir un risque aux trois autres responsabilités : en retouchant la notification, vous pouvez casser le calcul des droits. C’est ce que signifie concrètement le non-respect de la responsabilité unique. Un contrôleur devrait recevoir la requête et déléguer son traitement, pas porter lui-même les règles métier.
Le calcul des droits existe dansapproveet dans la méthode qui affiche le solde. Vous ne savez pas encore si les deux copies sont identiques, mais le ticket suggère fortement qu’elles ne le sont plus.
Ce type de divergence apparaît rarement d’un coup. Un développeur corrige un arrondi dans une méthode sans savoir qu’une copie du calcul existe ailleurs. Un autre réécrit une expression pour la rendre plus lisible, dans une seule des deux copies. Aucun d’eux ne commet d’erreur visible, et pourtant l’application finit par donner deux réponses différentes à la même question.
new NotificationService()lie la méthode à un système de notification précis : chaque exécution d’approve, y compris dans un test, déclenche une vraie notification. Les deux repositories, eux, sont fournis par Spring au constructeur du contrôleur. Vous verrez au chapitre 4 comment fonctionne ce mécanisme et comment l’étendre au reste du code. Mais le calcul des droits est enfoui entre deux accès à la base : pour le vérifier, il faut une base contenant un salarié et une demande.
C’est la raison pour laquelle les tests fournis démarrent toute l’application, et pourquoi ils sont si peu nombreux : écrire un test coûte cher quand chacun demande de préparer une base et des données. Le jour où vous ajouterez la règle des stages, vous rencontrerez le même obstacle. Impossible de la tester isolément, avec un simple test JUnit sur une classe.
Le calcul repose sur unif/elseappliqué à une chaîne de caractères. Pour ajouter les stages, il faudra ajouter une branche, et la dupliquer dans chaque copie du calcul.
Regardez aussi la dernière branche :d = 0. Si un salarié est enregistré avec le type"Cdd"au lieu de"CDD", aucune erreur n’est signalée. L’application lui attribue simplement zéro jour de congés, en silence. Une faute de frappe dans la base devient un bug métier, que seul le salarié concerné remarquera.
Une question reste ouverte : lorsque les deux calculs divergent, lequel a raison ? Le code ne peut pas vous répondre. Il dit ce que l’application fait, pas ce qu’elle devrait faire.
C’est une situation fréquente lors d’une reprise de code, et elle définit une limite de votre rôle : ce n’est pas au développeur de décider d’une règle métier. Choisir vous-même l’arrondi qui vous semble le plus logique reviendrait à fixer, seul, le nombre de jours de congés des salariés en CDD. La règle appartient au responsable RH : votre travail consiste à lui poser la bonne question, avec un exemple chiffré, puis à traduire sa réponse dans le code.
Vous avez donc écrit à Samuel :
Pour un salarié entré il y a 7 mois et 5 jours, faut-il compter 7 mois ou 8 ?
Sa réponse est arrivée dans l’heure : la règle accorde 2,08 jours par mois complet travaillé. Un mois commencé ne compte pas.
Votre diagnostic va mettre au jour plusieurs problèmes. Ils n’appellent pas tous le même traitement, et les distinguer permet de décider dans quel ordre les traiter.
Certains sont locaux : vous pouvez les corriger sans toucher au reste de l’application. C’est le cas des nomsd,mete, qui ne disent rien de leur rôle, ou des types de contrat écrits en dur, comme"CDD". Leur correction est rapide et peu risquée : elle ne modifie qu’un endroit du code.
D’autres relèvent de l’organisation du code : responsabilités mélangées, règle dupliquée, dépendances créées directement. Pour les corriger, il faut déplacer du code entre plusieurs classes, en changer les liens et vérifier que le comportement de l’ensemble n’a pas bougé. C’est plus long, plus risqué, et c’est aussi ce qui rend les évolutions futures possibles. Ce sera le travail du prochain chapitre.

Inès a bloqué une demi-heure demain matin pour faire le point. Elle attend un diagnostic écrit qui lui permette de décider de la suite : faut-il simplement corriger le calcul, ou revoir l’organisation du contrôleur avant d’ajouter les stages ?
Voici la méthode qui calcule le solde affiché, dans le même contrôleur :
@GetMapping("/balance")
public Object getBalance(@RequestParam long employeeId) {
var e = employeeRepository.findById(employeeId).orElse(null);
if (e == null) {
return "Employee not found";
}
double days;
if (e.getContractType().equals("CDI")) {
days = 25;
} else if (e.getContractType().equals("CDD")) {
double months = Math.ceil(ChronoUnit.DAYS.between(e.getHireDate(), LocalDate.now()) / 30.0);
days = months * 2.08;
} else if (e.getContractType().equals("Alternance")) {
days = 25 + 5;
} else {
days = 0;
}
return days - e.getDaysTaken();
}À vous d’établir le diagnostic complet, sans modifier le code :
Comparez le calcul des droits dansgetBalanceet dansapprove. Repérez ce qui diffère et expliquez, chiffres à l’appui, pourquoi la demande de Leïla Haddad est refusée. Elle est entrée il y a environ 7 mois et 5 jours, et elle a déjà pris 10 jours.
D’après la réponse de Samuel, lequel des deux calculs respecte la règle RH ?
Décrivez trois problèmes de maintenabilité. Pour chacun, indiquez où il se trouve, le critère qui permet de le justifier et sa conséquence concrète pour l’ajout des stages.
Classez chaque problème : local ou d’organisation ?
Proposez l’ordre dans lequel vous les traiteriez, et justifiez-le.
Notez votre diagnostic dans un fichierDIAGNOSTIC.mdà la racine du dépôt, puis enregistrez-le avec Git.
Avant de corriger un bug, reproduisez-le : vous connaîtrez les données qui le déclenchent et vous pourrez vérifier votre correction. Un test qui passe garantit seulement que le comportement testé n’a pas changé, pas que l’application est correcte.
Un symptôme isolé révèle souvent un problème d’organisation : ici, une règle métier dupliquée dans un contrôleur qui fait tout.
La grille de lecture du cours sur les design patterns (responsabilité unique, DRY, couplage, cohésion) permet de justifier chaque problème et ses conséquences.
Quand deux implémentations d’une règle divergent, c’est le métier qui tranche, pas le développeur.
Les problèmes locaux se corrigent sur place ; les problèmes d’organisation demandent de déplacer du code entre plusieurs classes.
Vous savez maintenant pourquoi Hamac est difficile à faire évoluer, et Inès a validé votre plan. Dans le prochain chapitre, vous allez traiter les problèmes d’organisation : séparer les responsabilités avec le pattern MVC, rassembler la règle de calcul et appliquer les principes SOLID.