Cours Vibe coding avec Claude Code · Module 11: Clone de Spotify

Les tests comme main courante : Claude s'arrête quand ils passent

12 min de lecture
Dans cette leçon10

Ohé ! Sea Shanty Sounds joue de la musique, il a des playlists et une recherche, et le projet contient plus de vingt tests des leçons 10_1 à 10_3. Chacun est né parce que tu avais ajouté à ta demande un critère de fin. Demain, tu demanderas un détail, tu oublieras le critère, et Claude s'arrêtera dès que le code aura l'air terminé. Dans cette leçon, les tests cessent d'être quelque chose dont tu te souviens dans la demande : ils deviennent la main courante à laquelle Claude se tient à chaque changement.

Ce que tu vas apprendre

  • écrire dans CLAUDE.md les commandes avec lesquelles Claude vérifie son travail ;
  • distinguer un test de comportement d'un test qui fouille dans la construction du code ;
  • casser le code exprès pour vérifier qu'un test surveille vraiment quelque chose ;
  • reconnaître dans le diff un test affaibli et un test qui ne vérifie rien ;
  • choisir le degré de rigueur : critère dans la demande, /goal, hook Stop, relecteur frais et /verify à la fin.

La ligne la plus précieuse de CLAUDE.md

Les bonnes pratiques de Claude Code le disent sans détour : si le projet a quelque chose qui répond "réussi" ou "échoué", la ligne la plus précieuse de CLAUDE.md est la commande qui le lance. Sea Shanty Sounds a quatre vérifications de ce genre : les tests, le lint, les types et le build. Écrites dans CLAUDE.md, elles arrivent dans chaque session, même celle de demain, sans que tu aies à les rappeler.

Demande pour Claude Code :

Ajoute à @CLAUDE.md une section "Commandes de vérification" : les tests
en une seule passe, le lint, les types et le build, chacun sur sa
propre ligne. En dessous, une phrase disant que le travail est fini
quand toutes passent et que je veux voir les commandes avec leurs
résultats. Dans les pièges, ajoute l'interdiction de modifier les
fichiers de tests sans mon accord. Lance chaque commande et montre
le résultat.

La demande nomme le fichier, dit ce qu'il doit contenir et exige une preuve, pas une assurance.

Ce que Claude a écrit : les commandes dans CLAUDE.md

Ouvre CLAUDE.md dans Cursor. Sous l'import @AGENTS.md, deux courtes sections :

# Commandes de vérification
- Tests : npm run test -- --run (Vitest, une seule passe sans mode watch)
- Lint : npm run lint
- Types : npx tsc --noEmit
- Build : npm run build
Le travail est fini quand les quatre passent. Montre les commandes et leurs résultats.

# Pièges
- Un test qui échoue se corrige dans le code. Tu ne modifies pas les fichiers *.test.ts et *.test.tsx sans mon accord.

Tu connais le drapeau --run depuis la leçon 4_1 : il coupe le mode watch, donc la commande se termine toute seule et Claude peut lire le résultat. Chez nous, les tests ont annoncé Test Files 7 passed (7) et Tests 22 passed (22), et le lint, les types et le build sont passés sans erreur. Rappelle-toi la leçon 1_7 : CLAUDE.md est une demande, pas un verrou. Le modèle s'y conforme presque toujours, mais ce n'est pas garanti.

Tester le comportement, pas les détails

Tous les tests verts ne sont pas une main courante. Testing Library, que les tests de composants du projet utilisent, repose sur un principe simple : un test donne d'autant plus de confiance qu'il ressemble à la façon dont une personne utilise l'application. Un test de comportement clique sur ce que clique le pirate et vérifie ce que le pirate voit. Un test de détails fouille dans la construction du code : il compte les éléments d'une liste, vérifie des classes ou si une fonction interne a été appelée.

Demande pour Claude Code :

Dans components/Queue.test.tsx, écris un test de comportement de la
file : un clic sur Retirer à côté de "Shanty de l'île" enlève
précisément ce morceau, "Tambours de bataille" restent dans la liste
et ce qui joue ne change pas. Cherche les éléments par rôle et par
nom, comme dans @components/MusicPlayer.test.tsx.

Ouvre components/Queue.test.tsx. L'essentiel du test ressemble à ceci :

render(<MusicPlayer tracks={tracks} />);
fireEvent.click(screen.getByRole("button", { name: "Retirer Shanty de l'île de la file" }));
expect(screen.queryByRole("button", { name: "Retirer Shanty de l'île de la file" })).toBeNull();
expect(screen.getByRole("button", { name: "Retirer Tambours de bataille de la file" })).toBeTruthy();
expect(screen.getByText("Hymne des pirates, Capitaine Redbeard")).toBeTruthy();

Le test importe render, screen et fireEvent depuis @testing-library/react. Ils fonctionnent grâce à l'ensemble de la leçon 4_1 : Vitest, le plugin @vitejs/plugin-react qui comprend le JSX, et jsdom, un faux navigateur activé dans vitest.config.mts par environment: "jsdom". render dessine le lecteur dans ce navigateur et fireEvent.click simule le clic du pirate. getByRole cherche un bouton par son rôle et son nom, celui que le lecteur d'écran lira à voix haute, donc par l'aria-label de la file de la leçon 10_1. queryByRole renvoie null quand le bouton n'existe pas, alors que getByRole lève une erreur dans ce cas : pour vérifier une absence, on prend la première. Le test ne sait rien de useState ni de filter, donc il survit à toute refonte du code qui ne change pas le comportement.

L'agent aime écrire une version plus courte : expect(container.querySelectorAll("ol > li")).toHaveLength(2). Nous avons essayé les deux versions sur un bug où Retirer enlève toujours le premier morceau de la liste "À suivre". La version qui compte est passée, parce qu'il restait deux éléments, mais pas les bons. Le test de comportement a échoué avec AssertionError: expected <button type="button" …(2)></button> to be null, et le lint n'a signalé qu'un avertissement sur un id inutilisé.

Casse le code exprès

Un test que tu n'as jamais vu rouge a pu ne rien surveiller du tout. La vérification de la vérification est simple : casse le code un instant et regarde si le test sonne l'alarme.

Casse formatTime dans @lib/format.ts pour un instant : renvoie les
secondes sans padStart. Lance les tests et montre le résultat. Puis
rétablis le code et relance les tests.

Chez nous, le résultat avec la fonction cassée contenait ces lignes :

 FAIL  lib/format.test.ts > formatTime > formate les minutes et les secondes
AssertionError: expected '2:5' to be '2:05' // Object.is equality
      Tests  2 failed | 21 passed (23)

Deux tests du formateur ont échoué : ils attendent "2:05" et ont reçu "2:5". Une fois le code rétabli, les 23 sont repassés. Une casse pareille est un changement fait avec l'outil d'édition de Claude, donc, si quelque chose tourne mal, tu l'annules avec /rewind de la leçon 0_6.

Deux erreurs de l'agent visibles dans le diff

La première est le test affaibli. Un agent qui tient à un résultat vert change l'attente au lieu du code. Voici le diff après lequel le formateur cassé a passé les 23 tests :

-    expect(formatTime(125)).toBe("2:05");
+    expect(formatTime(125)).toMatch(/^\d+:\d+$/);
     expect(formatTime(59)).toBe("0:59");
-    expect(formatTime(60)).toBe("1:00");
+    expect(formatTime(60)).toMatch(/^\d+:\d+$/);

L'expression régulière /^\d+:\d+$/ ne vérifie que la forme : des chiffres, deux-points, des chiffres. Le texte "2:5" la satisfait aussi, donc le test a cessé de surveiller le zéro de tête. L'agent a fait pareil avec la ligne de 3600 et avec le test des fractions.

La seconde est le test qui ne vérifie rien. Les deux cas ci-dessous sont passés chez nous avec le formateur cassé :

it("formate la durée du morceau", () => {
  expect(formatTime(125)).toBeTruthy();
});
it("formate un long morceau", () => {
  formatTime(3600);
});

toBeTruthy laisse passer n'importe quel texte non vide, et le second test n'a aucun expect. Pour ce second cas, Vitest a un réglage : selon la documentation, expect.requireAssertions agit comme si chaque test commençait par la vérification qu'il exécutera au moins une comparaison. Claude a ajouté une ligne à vitest.config.mts :

  test: {
    environment: "jsdom",
    expect: { requireAssertions: true },
  },

Le test vide a alors échoué avec Error: expected any number of assertion, but got none, et celui avec toBeTruthy passait toujours. Le réglage attrape un test sans comparaison, mais une comparaison trop faible, toi seul la verras. C'est pourquoi, après chaque tour, tu jettes un œil à Source Control : un changement dans un fichier .test.ts ou .test.tsx que tu n'as pas demandé est le signal d'arrêter et de demander pourquoi.

Les degrés de rigueur

Les bonnes pratiques citent quatre degrés pour s'assurer que le travail est fini, du plus souple à celui que le programme impose lui-même.

  1. Le critère dans la demande, comme le "Ce sera fini quand :" de la leçon 10_1. Claude juge seul quand il est content.
  2. /goal fixe une condition de fin. Après chaque tour, un modèle distinct la vérifie d'après la conversation, et Claude continue tant que la condition n'est pas remplie. Ce modèle ne lance pas de commandes et ne lit pas de fichiers, donc la condition doit se lire dans les résultats que Claude montre. La documentation conseille d'ajouter une limite, par exemple que les autres fichiers de tests ne changent pas, et un plafond de tours.
  3. Le hook Stop de la location 7 : une commande que Claude Code lance à chaque tentative de terminer le tour. Le code de sortie 2 renvoie Claude au travail, et le texte de la sortie d'erreur lui parvient comme motif.
  4. Un relecteur qui n'a pas écrit le code : /code-review de la leçon 2_9 lit le diff dans un sous-agent frais qui n'a pas vu votre conversation.

La condition de /goal s'écrit sur une seule ligne :

/goal npm run test -- --run se termine sans échec, npm run lint et npx tsc --noEmit passent, et git diff --stat ne montre aucun changement dans les fichiers .test.ts ni .test.tsx ; ou arrête-toi après 15 tours

Fixer l'objectif démarre aussitôt un tour, et /goal clear le supprime. L'objectif ne change pas le mode de permissions : en mode Manual, Claude demande encore pour les commandes sans règle. La documentation ajoute honnêtement qu'il est rarement utile dans une session que tu regardes ; il sert pour un long travail sans toi.

Tu ajoutes le hook Stop à .claude/settings.json sous la forme connue de la location 7 :

{
  "hooks": {
    "Stop": [
      { "hooks": [{ "type": "command", "command": "npm run test -- --run 1>&2 || exit 2" }] }
    ]
  }
}

1>&2 envoie le résultat des tests vers la sortie d'erreur pour que Claude le voie, et || exit 2 termine la commande avec le code 2 quand les tests tombent. Chez nous, cette commande s'est terminée avec le code 0 sur des tests verts et avec le code 2, échecs sur la sortie d'erreur, avec le formateur cassé. Selon la documentation, après huit blocages d'affilée, Claude Code termine tout de même le tour. Garde le coût en tête : les tests partent après chaque tour, même après la réponse à une simple question. Au quotidien, je recommande les commandes dans CLAUDE.md et le critère dans la demande, /goal pour un long travail sans surveillance, le hook quand des tests verts doivent être une loi sans exception, et /code-review avant le commit.

/verify : l'application, pas seulement les tests

Les tests vérifient des fonctions et des composants dans un faux navigateur. Selon la documentation, le skill intégré /verify demande à Claude de construire et de lancer l'application puis de regarder le résultat, et il attrape ce que les tests et les types ne voient pas. Tu le lances toi-même quand Claude annonce la fin du travail. Il marche sans configuration : il devine le lancement d'après package.json et le README. Quand il a dû le déterminer, il écrit la recette dans .claude/skills/verify/SKILL.md. Le projet a alors son propre skill nommé verify, et la documentation dit qu'une session qui démarre avec un tel skill reçoit dans ses instructions de commit l'ordre de le lancer avant chaque commit, sauf pour les changements de documentation seule ou de tests. De lui-même, Claude ne lance pas le /verify intégré avant un commit.

Une dernière limite. La documentation de Next.js écrit que Vitest ne gère pas encore les Server Components asynchrones et recommande pour eux des tests E2E dans un navigateur. Jest figure dans cette documentation à côté de Vitest comme option équivalente ; depuis la leçon 4_1, le cours reste sur Vitest.

La revue du capitaine

  1. Les commandes tournent. Dans la réponse de Claude, tu vois les quatre commandes de CLAUDE.md et leurs résultats, pas la phrase "tout passe".
  2. Le diff des tests. Chaque changement dans les fichiers .test.ts et .test.tsx est un changement que tu as demandé. L'erreur typique de l'agent est une attente assouplie pour que le code cassé passe.
  3. Rouge au moins une fois. Chaque nouveau test, tu l'as vu rouge après avoir cassé le code exprès.
  4. Rôle et nom. Les tests de composants cherchent les éléments comme les cherche le pirate, pas par le nombre d'éléments ni par les classes.

Étape suivante

Demande un commit, par exemple "Commandes de vérification dans CLAUDE.md et test de la file". Puis un petit pas dans la même boucle : "Ajoute un test de comportement : le bouton Aléatoire ne change pas le morceau qui joue. Montre-le rouge après avoir cassé shuffled exprès, puis vert". Dans l'éditeur ci-dessous t'attend un petit pont d'essai avec formatTime : casse la fonction, enclenche l'erreur de l'agent avec le test affaibli et compare le résultat à ce que montre le diff.

Retiens : la main courante ne tient que si personne ne l'a dévissée en douce, et des tests verts ne comptent qu'avec le diff des fichiers de tests.

Code de cette leçon : App.jsx
// Pont d'essai : formatTime, tests Vitest en miniature et deux erreurs de l'agent
import { useState } from 'react';

function formatTimeGood(seconds) {
  if (!Number.isFinite(seconds) || seconds < 0) return '0:00';
  const whole = Math.floor(seconds);
  return `${Math.floor(whole / 60)}:${String(whole % 60).padStart(2, '0')}`;
}

// Version cassée : secondes sans padStart
function formatTimeBroken(seconds) {
  if (!Number.isFinite(seconds) || seconds < 0) return '0:00';
  const whole = Math.floor(seconds);
  return `${Math.floor(whole / 60)}:${whole % 60}`;
}

const SHAPE = /^\d+:\d+$/;

// Chaque test : nom, entrée, attente (toBe) ou attente affaiblie (toMatch)
const CASES = [
  { name: 'formate 125 secondes', input: 125, expected: '2:05', weakened: true },
  { name: 'formate 59 secondes', input: 59, expected: '0:59', weakened: false },
  { name: 'formate une minute pleine', input: 60, expected: '1:00', weakened: true },
  { name: 'formate une heure', input: 3600, expected: '60:00', weakened: true },
  { name: 'une durée inconnue donne 0:00', input: NaN, expected: '0:00', weakened: false },
];

function runCase(c, fn, weaken) {
  const value = fn(c.input);
  if (weaken && c.weakened) {
    return { pass: SHAPE.test(value), detail: `toMatch(/^\\d+:\\d+$/) a reçu "${value}"` };
  }
  const pass = value === c.expected;
  return { pass, detail: pass ? `toBe("${c.expected}")` : `expected '${value}' to be '${c.expected}'` };
}

export default function App() {
  const [broken, setBroken] = useState(false);
  const [weaken, setWeaken] = useState(false);
  const [emptyTest, setEmptyTest] = useState(false);
  const [requireAssertions, setRequireAssertions] = useState(false);
  const [result, setResult] = useState(null);

  function runTests() {
    const fn = broken ? formatTimeBroken : formatTimeGood;
    const rows = CASES.map((c) => ({ name: c.name, ...runCase(c, fn, weaken) }));
    if (emptyTest) {
      // Test sans expect : il passe, sauf si tu actives requireAssertions
      rows.push({
        name: 'formate un long morceau (sans expect)',
        pass: !requireAssertions,
        detail: requireAssertions ? 'expected any number of assertion, but got none' : "aucune comparaison, rien n'a été vérifié",
      });
    }
    setResult(rows);
  }

  const failed = result ? result.filter((r) => !r.pass).length : 0;
  const testsChanged = weaken || emptyTest;

  return (
    <div className="min-h-screen bg-gray-950 p-4 text-white">
      <div className="mx-auto max-w-xl space-y-4">
        <h1 className="text-lg font-semibold">Pont d&apos;essai : formatTime</h1>

        <div className="space-y-1 rounded-xl bg-gray-900 p-3 text-sm">
          <label className="flex items-center gap-2">
            <input type="checkbox" checked={broken} onChange={(e) => setBroken(e.target.checked)} />
            Casse formatTime exprès (sans padStart)
          </label>
          <label className="flex items-center gap-2">
            <input type="checkbox" checked={weaken} onChange={(e) => setWeaken(e.target.checked)} />
            Erreur de l&apos;agent : test affaibli (toBe remplacé par toMatch)
          </label>
          <label className="flex items-center gap-2">
            <input type="checkbox" checked={emptyTest} onChange={(e) => setEmptyTest(e.target.checked)} />
            Erreur de l&apos;agent : test sans aucun expect
          </label>
          <label className="flex items-center gap-2">
            <input type="checkbox" checked={requireAssertions} onChange={(e) => setRequireAssertions(e.target.checked)} />
            vitest.config.mts: expect.requireAssertions = true
          </label>
        </div>

        <button type="button" onClick={runTests} className="rounded-full bg-white px-4 py-2 font-semibold text-black">
          npm run test -- --run
        </button>

        {result && (
          <div className="rounded-xl bg-black p-3 font-mono text-xs">
            {result.map((r) => (
              <p key={r.name} className={r.pass ? 'text-green-400' : 'text-red-400'}>
                {r.pass ? '✓' : '×'} {r.name}: {r.detail}
              </p>
            ))}
            <p className="mt-2 text-gray-300">
              Tests {failed > 0 ? `${failed} failed | ` : ''}{result.length - failed} passed ({result.length})
            </p>
          </div>
        )}

        <div className="rounded-xl bg-gray-900 p-3 text-sm">
          <p className="text-gray-400">Source Control : fichiers modifiés</p>
          {broken && <p>M lib/format.ts</p>}
          {testsChanged ? <p className="text-amber-400">M lib/format.test.ts</p> : null}
          {!broken && !testsChanged && <p className="text-gray-500">Aucun changement.</p>}
          {weaken && (
            <pre className="mt-2 overflow-x-auto text-xs">
              <span className="text-red-400">{'-    expect(formatTime(125)).toBe("2:05");'}</span>{'\n'}
              <span className="text-green-400">{'+    expect(formatTime(125)).toMatch(/^\\d+:\\d+$/);'}</span>
            </pre>
          )}
        </div>

        {result && failed === 0 && broken && (
          <p className="rounded-xl bg-red-900 p-3 text-sm font-semibold">
            Le code est cassé et les tests sont verts. Quelqu&apos;un a dévissé la main courante : lis le diff du fichier de tests.
          </p>
        )}
        {result && failed === 0 && !broken && testsChanged && (
          <p className="rounded-xl bg-amber-900 p-3 text-sm">
            Tout est vert, mais le fichier de tests a changé. Casse formatTime et vérifie que le test surveille encore quelque chose.
          </p>
        )}
        {result && failed > 0 && (
          <p className="rounded-xl bg-gray-800 p-3 text-sm">Rouge : la main courante tient. Corrige le code, pas le test.</p>
        )}
      </div>
    </div>
  );
}

Tu as repéré une erreur dans cette leçon ?

Teste tes connaissances

Réponds aux questions de cette leçon. Choisis une réponse pour voir tout de suite si elle est correcte.

  1. 1. De quoi un projet Next.js a-t-il besoin pour que Vitest exécute un test de composant, comme le test de la file ?

  2. 2. Que fait fireEvent.click(...) dans le test de la file ?

Tâches pratiques dans le jeu

  • Clique dans l'ordre

    Clique pour construire l'import des outils qu'utilise le test de la file :

  • Tri vertical

    Ordonne les étapes du test de comportement qui vérifie le bouton Retirer de la file :

  1. QuestionEnsemble pour tester des composants
  2. QuestionLa fonction fireEvent.click
  3. Clique dans l'ordreConstruis l'import de testing-library
  4. Remets dans l'ordreÉtapes du test de la file

Articles utiles