Aller au contenu
Mastering Claude

Accueil / Gestes courants

Gestes courants10 minApplication

Construire et refactorer avec les tests d'abord

Claude Code examine les fichiers de test déjà présents dans un projet pour écrire un nouveau test dans le même style avant l'implémentation, et confirmer que ce test échoue réellement prouve qu'il teste bien quelque chose qui n'existe pas encore.

Claude examine les fichiers de test déjà présents dans un dépôt pour reproduire leur style, leur cadre de test et leurs conventions d'assertion, plutôt que d'imposer une convention étrangère au projet. Le geste consiste à demander ces tests avant d'écrire l'implémentation qu'ils doivent vérifier, puis à lancer le lanceur de tests pour constater qu'ils échouent réellement.

Confirmer le rouge avant de demander le vert

Cette séquence, connue en génie logiciel sous le nom de rouge, vert, refactor, ne dépend d'aucune fonctionnalité spécifique de Claude Code, elle reste valable avec n'importe quel outil. Le rouge prouve que le test peut échouer, le vert prouve que l'implémentation le satisfait, et sauter directement au vert sans avoir vu le rouge laisse ouverte une question gênante : celle de savoir si le test aurait passé même sans aucune implémentation.

L'exemple suivant fabrique ses propres données pour rester valable à toute lecture. Un test attend qu'une fonction calculerRemise applique dix pour cent de réduction, avant même que cette fonction existe.

function testCalculerRemise() {
  const resultat = calculerRemise(200);
  console.assert(resultat === 180, "attendu 180, obtenu " + resultat);
}

testCalculerRemise();
// ReferenceError: calculerRemise is not defined, le rouge attendu

Une fois ce rouge constaté, l'implémentation minimale suffit à le faire passer au vert.

function calculerRemise(prix) {
  return prix * 0.9;
}

testCalculerRemise();
// aucune sortie : l'assertion est vraie, le test est au vert

Refactorer une préoccupation à la fois

Le lanceur de tests reste actif pendant tout le refactor qui suit, et chaque modification porte sur une seule préoccupation, un seul nom renommé, une seule fonction extraite, jamais plusieurs à la fois dans le même tour. Cette discipline isole la régression : si le lanceur de tests échoue après un changement, la cause tient dans ce changement précis, pas dans un ensemble de modifications empilées qu'il faudrait démêler. Demander explicitement à Claude d'identifier les cas limites non couverts avant de considérer une série de tests terminée complète le tableau, en particulier sur les entrées vides, négatives ou hors bornes que l'implémentation initiale ignore souvent.

Cette exigence de preuve exécutée rejoint le test de régression qui clôt une correction de bug : dans les deux cas, la confiance vient d'une sortie lue, pas d'une lecture du code.

Figure 1

Rouge, vert, refactor

01
Test écrit
Un test qui décrit le comportement attendu est écrit avant toute implémentation.
02
Rouge constaté
Le lanceur de tests est exécuté et son échec confirme que le test teste bien quelque chose d'absent.
03
Implémentation minimale
Le code le plus court qui satisfait le test est écrit, sans anticiper des besoins non testés.
04
Vert obtenu
Le lanceur de tests est relancé et sa sortie confirme que l'implémentation satisfait le test.
05
Refactor ciblé
Une seule préoccupation est retouchée à la fois, avec le lanceur de tests actif en continu pour isoler toute régression.
La séquence montre que le rouge n'est pas une étape sautable : il prouve que le test peut échouer avant que le vert ne prouve que l'implémentation le satisfait.
Calibrez vous-même

Une développeuse demande à Claude Code d'écrire un test pour une fonction de calcul de remise avant d'écrire cette fonction. Elle exécute ce test et lit le message d'erreur affiché dans le terminal.

Écrivez en une phrase ce que cette situation établit, et en une phrase ce qu'elle n'établit pas.

Ce qu’il faut retenir
  • Claude examine les fichiers de test déjà présents dans le dépôt pour reproduire leur style et leurs conventions d'assertion, plutôt que d'en imposer une nouvelle.
  • Le rouge prouve que le test peut échouer et le vert prouve que l'implémentation le satisfait, sauter directement au vert laisse ouverte la question d'un test qui aurait passé sans rien implémenter.
  • Un refactor porte sur une seule préoccupation à la fois, avec le lanceur de tests actif en continu, pour isoler la cause de chaque régression.
  • Demander explicitement les cas limites non couverts, entrées vides, négatives ou hors bornes, complète une série de tests que l'implémentation initiale ignore souvent.
À faire maintenant

Choisissez une petite fonction que vous devez encore écrire aujourd'hui, demandez à Claude Code d'écrire d'abord le test à partir des conventions de votre projet, exécutez ce test pour vérifier qu'il échoue réellement, puis écrivez l'implémentation minimale qui le fait passer au vert.

Vérifier à la source

Chaque affirmation datable de cette leçon renvoie ici au texte public qui la porte. Une source qui ne s’ouvre pas ne prouve rien.