
Inès a lu votre diagnostic. Sa réponse tient en deux phrases :
D’accord sur l’ordre. Mais je ne veux pas d’un correctif d’arrondi : je veux que ce bug ne puisse plus exister.
De son côté, Samuel a précisé son calendrier : la première stagiaire arrive dans deux mois, et ses congés devront être gérés par Hamac dès son arrivée.
RemplacerMath.CeilingparMath.Floorprendrait une minute. Mais la règle resterait copiée dans deux méthodes, au milieu de l’accès aux données et des notifications. La règle des stages devrait être ajoutée dans ces mêmes méthodes, avec les mêmes risques de divergence. Pour satisfaire Inès, il faut changer l’organisation du code, pas seulement une ligne.
Pourquoi une organisation d’ensemble ?
Les principes que vous avez utilisés dans votre diagnostic, comme la responsabilité unique, s’appliquent à une classe ou à une méthode. Ils vous disent qu’Approveen fait trop, mais pas où ranger ce que vous allez en sortir. Une application a aussi besoin d’une organisation d’ensemble, partagée par toute l’équipe : où placer les règles métier ? Qui reçoit les requêtes ? Qui décide de ce qui est affiché ?
C’est précisément ce qui a manqué à Hamac. Sans organisation convenue, chacun des trois développeurs successifs a placé son code à l’endroit le plus pratique sur le moment. Et l’endroit le plus pratique, dans une API, c’est presque toujours le contrôleur : c’est là qu’arrive la requête.
Le pattern MVC, pour Model-View-Controller, répond à ces questions en distinguant trois rôles :
le modèle représente les données et les règles métier : un salarié, une demande de congés, le calcul des droits ;
la vue présente ces données à l’utilisateur ;
le contrôleur reçoit une action de l’utilisateur, demande au modèle de la traiter, puis choisit la réponse à renvoyer.
MVC est un pattern architectural : il ne décrit pas la collaboration de quelques objets, comme Strategy, mais la répartition des responsabilités dans toute l’application. Son intérêt principal est de protéger les règles métier : elles ne dépendent ni de la façon dont on les affiche, ni de la façon dont on les déclenche.
Dans Hamac, ces rôles se répartissent ainsi :
Rôle | Dans Hamac |
Modèle | Les entités |
Vue | Les écrans du front-end Blazor, qui affichent les données reçues de l’API en JSON |
Contrôleur |
|
Vous remarquez que la vue ne se trouve pas dans le projet de l’API. C’est le cas de toutes les API : elles renvoient des données, et c’est une autre application, ici le front-end Blazor, qui se charge de les présenter. Le contrôleur reste le point d’entrée, mais sa réponse est du JSON plutôt qu’une page HTML.
Pour garder les règles métier hors du contrôleur, on les place généralement dans une couche service. L’application s’organise alors en couches qui s’appellent dans un seul sens :
le contrôleur reçoit la requête et traduit le résultat en réponse HTTP ;
le service applique les règles métier, comme « une demande n’est approuvée que si le solde la couvre » ;
l’accès aux données lit et enregistre les entités. Dans Hamac, c’est le rôle deHamacDbContext, fourni par Entity Framework Core.
Le service et l’accès aux données appartiennent tous deux au modèle de MVC. Les couches précisent simplement son organisation interne.
Pourquoi insister sur le sens des appels ?
Parce qu’il détermine ce que chaque couche peut ignorer. Le contrôleur connaît le service, mais le service ne sait rien de HTTP : il ne manipule ni requête, ni statut, ni JSON. Le jour où Samuel demandera un recalcul automatique des soldes chaque fin de mois, une tâche planifiée pourra appeler le même service, sans passer par l’API et sans dupliquer la règle.
Retenez ce test simple : un contrôleur bien organisé ne contient ni règle métier, ni accès direct aux données. Il orchestre. Si vous pouvez lire une règle RH dans votre contrôleur, elle n’est pas au bon endroit.
Si je déplace tout le contenu du contrôleur dans un service, celui-ci ne va-t-il pas devenir à son tour une classe qui fait tout ?
C’est un risque réel. Un service qui reçoit tout le code d’un contrôleur trop gros devient simplement un service trop gros. La couche service indique où placer les règles métier, mais pas comment les découper. C’est le rôle des principes SOLID, que vous allez appliquer dans la suite de ce chapitre.
SOLID regroupe cinq principes de conception objet. Vous en connaissez déjà le premier, la responsabilité unique. Les quatre autres prolongent les mécanismes vus dans le cours sur les design patterns : contrats, polymorphisme, composition et injection.
Chacun se traduit par une question à poser sur le code de Hamac :
Principe | Ce qu’il impose | La question à poser dans Hamac |
S — Responsabilité unique | Une classe n’a qu’une raison de changer. | Où vit la règle de calcul des droits ? |
O — Ouvert/fermé | On ajoute un comportement sans modifier le code existant. | Que faut-il modifier pour ajouter les stages ? |
L — Substitution de Liskov | Toute implémentation d’un contrat peut en remplacer une autre. | Le service peut-il faire confiance à n’importe quelle politique de calcul ? |
I — Ségrégation des interfaces | On ne dépend que des méthodes dont on a besoin. | De quoi le traitement des congés a-t-il besoin pour notifier un salarié ? |
D — Inversion des dépendances | Le métier dépend d’abstractions, pas de détails techniques. | Qui crée les collaborateurs du service ? |
Plutôt que de les étudier un par un, de façon abstraite, vous allez les rencontrer dans l’ordre où le refactoring de Hamac les fait apparaître.
Le premier refactoring traite la cause du bug. Le calcul des droits change pour une seule raison, l’évolution des règles RH décidées par Samuel : il mérite donc sa propre place, hors du contrôleur.
Commencez par définir le contrat d’une politique de calcul :
public interface ILeaveEntitlementPolicy
{
double ComputeEntitlement(Employee employee, DateTime today);
}La date du jour est passée en paramètre plutôt que lue avecDateTime.Todayà l’intérieur du calcul. Ce détail a une conséquence importante. Un calcul qui lit lui-même la date du jour donne un résultat différent chaque mois : un test qui vérifie « 14,56 jours » passerait aujourd’hui et échouerait le mois prochain. En recevant la date, la politique devient prévisible : pour un même salarié et une même date, elle renvoie toujours le même résultat.
Chaque type de contrat devient une politique concrète. Voici celle des CDD, qui reprend le calcul confirmé par Samuel, celui des mois complets :
public sealed class FixedTermContractPolicy : ILeaveEntitlementPolicy
{
private const double DaysPerFullMonth = 2.08;
public double ComputeEntitlement(Employee employee, DateTime today)
{
var fullMonths = Math.Floor((today - employee.HireDate).TotalDays / 30);
return fullMonths * DaysPerFullMonth;
}
}Comparez avec le starter :detmsont devenusfullMonthsetDaysPerFullMonth. Le nom de la variable dit maintenant ce que Samuel vous a confirmé : on compte des mois complets. Un développeur qui serait tenté d’utiliserMath.Ceilingverrait immédiatement la contradiction.
La division par 30, elle, reste une approximation du mois. Vous la conservez telle quelle : un refactoring ne change pas la règle, il la range. Si l’entreprise décide un jour de compter les mois calendaires, il n’y aura plus qu’une seule classe à modifier.
Le principe ouvert/fermé, ou OCP pour Open/Closed Principle, demande qu’un module soit ouvert à l’extension mais fermé à la modification. Autrement dit, ajouter un comportement ne devrait pas obliger à modifier du code déjà écrit et testé.
Avec l’if/elsedu starter, ajouter les stages imposait de modifier deux méthodes qui fonctionnaient, au risque de les casser. Avec des politiques séparées, il faut maintenant un endroit unique qui associe chaque type de contrat à sa politique :
public sealed class LeavePolicyResolver
{
private readonly IReadOnlyDictionary<string, ILeaveEntitlementPolicy> _policies;
public LeavePolicyResolver(IReadOnlyDictionary<string, ILeaveEntitlementPolicy> policies) =>
_policies = policies;
public ILeaveEntitlementPolicy For(string contractType) =>
_policies.TryGetValue(contractType, out var policy)
? policy
: throw new InvalidOperationException($"Unknown contract type: {contractType}");
}Le résolveur reçoit un dictionnaire qui associe un type de contrat à sa politique, et renvoie celle qui correspond. Pour ajouter les stages, il suffira de créer une nouvelle politique et de l’enregistrer dans ce dictionnaire. Le service et les politiques existantes ne changeront pas.
Remarquez le comportement face à un type inconnu. Le starter attribuait silencieusement zéro jour, ce qui transformait une faute de frappe en bug métier. Le résolveur lève une exception : un type de contrat inconnu est une erreur de données, et il vaut mieux qu’elle soit visible immédiatement plutôt que découverte par un salarié privé de congés.
OCP n’est pas pour autant une interdiction absolue de modifier du code. Le dictionnaire, lui, devra recevoir une ligne de plus. Mais cette modification se limite à un point d’assemblage, sans aucune règle métier : elle ne peut pas casser le calcul des CDI.
Le principe de substitution de Liskov, ou LSP, demande que toute implémentation d’un contrat puisse remplacer une autre sans surprendre le code qui l’utilise.
Ce principe prend tout son sens avec le résolveur. Le service ne sait pas quelle politique il reçoit : il appelleComputeEntitlementet fait confiance au résultat. Cette confiance n’est justifiée que si toutes les politiques respectent le même contrat.
Imaginez une politique des stages qui lancerait uneNotSupportedExceptionpour un stagiaire arrivé depuis moins d’un mois, ou qui renverrait-1pour signifier « pas de congés ». Le service calculerait alors un solde absurde, ou planterait, sans que rien dans son code ne le laisse prévoir. Pour l’éviter, chaque politique doit respecter le même contrat implicite : renvoyer un nombre de jours positif ou nul pour tout salarié valide. Si un salarié n’a encore acquis aucun droit, sa politique renvoie0.
Vous voyez la différence avec le résolveur :0signifie « ce salarié n’a pas de droits », alors que l’exception du résolveur signifie « ce type de contrat n’existe pas ». Le premier cas est une situation métier normale, le second une erreur.
Le principe de ségrégation des interfaces, ou ISP, recommande des interfaces ciblées plutôt qu’une interface qui fait tout.
Dans Hamac,NotificationServicepropose plusieurs méthodes : notifier un salarié, envoyer un récapitulatif hebdomadaire aux managers, renvoyer les notifications en échec. Le traitement des congés n’a besoin que de la première. S’il dépendait de toute la classe, il serait concerné par chacune de ses évolutions, même celles qui ne le regardent pas. Définissez donc une interface limitée à ce besoin :
public interface ILeaveNotifier
{
void Notify(Employee employee, string message);
}NotificationServicel’implémente, sans autre modification. Le bénéfice apparaîtra dans les tests : le jour où vous remplacerez le notificateur par un faux, celui-ci n’aura qu’une méthode à écrire, et non trois.
N’en concluez pas qu’il faut découper chaque interface en méthodes isolées par précaution. ISP s’applique quand un client utilise une partie seulement d’une classe plus large, comme ici. Une interface dont tous les clients utilisent toutes les méthodes n’a pas besoin d’être découpée.
Le principe d’inversion des dépendances, ou DIP, demande que le code métier dépende d’abstractions, et non de détails techniques.
Le nouveauLeaveServicene crée plus rien lui-même. Il reçoit ses collaborateurs par son constructeur : le résolveur de dépendances, unILeaveNotifieret leHamacDbContext. Les règles métier ne savent plus comment une notification est envoyée, ni quelle classe calcule les droits d’un CDD. C’est ce qui rendra possibles les tests isolés que vous ne pouviez pas écrire au chapitre précédent.
Pourquoi ne pas cacher aussiHamacDbContextderrière une interface ?
LeDbContextd’Entity Framework Core est déjà une abstraction de la base de données : il fonctionne avec SQLite, SQL Server ou PostgreSQL sans que votre code change. Ajouter un repository générique par-dessus dupliquerait ce qu’il fait déjà, sans bénéfice pour Hamac. Vous verrez au chapitre 4 comment le framework le fournit au service.
En attendant ce chapitre, quelqu’un doit bien créer ces objets et les assembler. Pour l’instant, ce sera le constructeur du contrôleur. Ce n’est pas idéal, puisque le contrôleur connaîtra toutes les classes concrètes, mais c’est une étape provisoire et assumée. Vous refactorez une chose à la fois, et la création des objets sera confiée au framework dans le prochain chapitre.
Un refactoring modifie l’organisation du code sans changer son comportement observable. C’est cette contrainte qui le rend sûr : si les tests passent avant et après, rien n’a changé pour les utilisateurs.
Le réflexe le plus risqué consiste à tout réécrire d’un coup, puis à lancer les tests à la fin. Si l’un d’eux échoue, vous ne savez pas laquelle de vos vingt modifications l’a cassé. Avancez donc par petites étapes, et relancezdotnet testaprès chacune :
Écrivez d’abord un test qui reproduit le bug. Il échoue sur le starter : c’est normal, il prouve que le problème existe. Quand il passera, vous saurez que le bug est corrigé, et il empêchera ce bug de revenir.
Extrayez les politiques et le résolveur. Remplacez les types de contrat écrits en dur par des constantes.
Créez le service et déplacez-y la logique deGetBalanceet d’Approve.
Allégez le contrôleur : il appelle le service et traduit son résultat en réponse HTTP.
Vérifiez que tous les tests passent, y compris celui du bug.
Les réponses de l’API ne changent pas : mêmes routes, mêmes messages. Seule la valeur du solde des CDD est corrigée. Ce choix peut sembler frustrant, puisque vous savez déjà que ces routes sont mal conçues. Mais le front-end et les tests existants s’appuient sur elles : les modifier maintenant mélangerait deux changements, et un test en échec ne vous dirait plus lequel est en cause.
Pour la même raison, le filtrage aprèsToList()attendra le chapitre 4.

Inès vous laisse jusqu’à vendredi pour proposer votre refactoring. Elle le relira avec une exigence : en dehors du solde des CDD, le comportement de l’API ne doit pas changer.
Partez de votreDIAGNOSTIC.mdet suivez les étapes ci-dessus :
DansLeaveApiTests.cs, sur le modèle des tests existants, ajoutez un test qui vérifie que le solde affiché pour Leïla Haddad (salariée n° 4) vaut environ 4,56 jours. Vérifiez qu’il échoue.
Créez une classeContractTypescontenant les trois types de contrat sous forme de constantes.
CréezILeaveEntitlementPolicyet ses trois implémentations :PermanentContractPolicy,FixedTermContractPolicyetApprenticeshipPolicy.
CréezLeavePolicyResolveretILeaveNotifier, puis faites implémenterILeaveNotifierparNotificationService.
CréezLeaveService, avec une méthodeGetBalanceet une méthodeApprove.
AllégezLeaveControlleret assemblez les objets dans son constructeur.
Ajoutez un test unitaire pourFixedTermContractPolicy, sans base de données.
Point de contrôle : tous les tests passent, y compris les deux nouveaux. Le solde affiché pour Leïla Haddad est le même que celui utilisé à l’approbation. Enregistrez votre travail avec Git.
MVC répartit les rôles à l’échelle de l’application : le modèle porte les données et les règles métier, la vue les présente, le contrôleur orchestre.
Une couche service garde les règles métier hors du contrôleur. Un contrôleur bien organisé ne contient ni règle métier, ni accès direct aux données.
Rassembler une règle en un seul endroit supprime la cause d’une divergence, pas seulement son symptôme.
OCP permet d’ajouter un comportement sans modifier le code déjà testé ; LSP garantit que chaque implémentation respecte le même contrat. ISP conduit à des interfaces ciblées ; DIP fait dépendre le code métier d’abstractions plutôt que de détails techniques.
Un refactoring sûr avance par petites étapes vérifiées par les tests, en traitant un problème à la fois.
Le bug de Leïla est corrigé, et la règle de calcul n’existe plus qu’à un seul endroit. Mais les objets de Hamac sont encore assemblés à la main dans le contrôleur. Dans le prochain chapitre, vous allez confier ce travail à ASP.NET Core : enregistrer vos services dans le conteneur .NET, les injecter par constructeur et accéder correctement aux données avec Entity Framework Core.