Chapitre 15 – Les Internals des Tests

Clean Code — Chapitre 15 : Les Internals des Tests

Le chapitre 15 est un cas d'étude fascinant. Martin y analyse le code de JUnit lui-même — le framework de tests Java — et montre comment même du code de qualité peut être amélioré. Le message : les tests sont du code de production. Ils méritent la même attention.

💡 L'idée clé du chapitre :

"Le code de test doit être aussi propre que le code de production. Les mêmes principes s'appliquent : noms clairs, fonctions courtes, pas de duplication."

  • Tests = code de première classe — Pas de compromis sur la qualité
  • Lisibilité avant tout — Un test doit se lire comme une spécification
  • DRY dans les tests — Factoriser helpers, builders, fixtures
  • Un concept par test — Éviter les tests fourre-tout

1. Qualité du code de test

Martin commence par une affirmation forte : le code de test doit être aussi propre que le code de production. Pourquoi ? Parce que des tests sales = code de production impossible à faire évoluer.

Tests sales : Spirale descendante vs Cercle vertueux 💀 Spirale de la mort 1️⃣ Tests sales écrits "On gagnera du temps" 2️⃣ Tests difficiles à changer Couplage fort, duplication 3️⃣ Tests ignorés "Trop dur à maintenir" 4️⃣ Code fragile Bugs en prod, perte confiance ↻ Répétition ⚠️ Descente continue ✅ Cercle vertueux 1️⃣ Tests propres écrits Lisibles, maintenables 2️⃣ Refactor facile Confiance totale 3️⃣ Code robuste Filet de sécurité solide 4️⃣ Qualité croissante Amélioration continue ✅ Amélioration continue Le choix initial détermine la trajectoire : descente ou montée

⚠️ Le mythe du "test rapide et sale" :

"On va juste écrire des tests sales pour gagner du temps, on nettoiera plus tard." — Ce plus tard n'arrive jamais. Les tests sales s'accumulent et rendent le code impossible à refactorer.

2. Lisibilité des tests

Un test doit se lire comme une spécification vivante du comportement. Le pattern AAA (Arrange-Act-Assert) aide à structurer cette lisibilité.

Pattern AAA (Arrange-Act-Assert) 1. ARRANGE Préparer le contexte : • Créer objets • Mocker dépendances • Initialiser état ⏱️ ~30% du test 2. ACT Exécuter l'action : • Appeler fonction • Déclencher événement • 1 ligne idéalement ⏱️ ~10% du test 3. ASSERT Vérifier résultat : • toEqual, toBe • toHaveBeenCalled • État final correct ⏱️ ~60% du test

❌ Test illisible

test("user", async () => {
  const u = { id: 1, n: "Bob" };
  const r = await f(u);
  expect(r).toBe(true);
  expect(m).toHaveBeenCalled();
});

// ⚠️ Que teste-t-on ?
// ⚠️ Noms cryptiques
// ⚠️ Pas de structure

✅ Test lisible (AAA)

test("valide utilisateur actif", 
  async () => {
  // ARRANGE
  const activeUser = {
    id: 1,
    name: "Bob",
    status: "active"
  };
  
  // ACT
  const isValid = 
    await validateUser(activeUser);
  
  // ASSERT
  expect(isValid).toBe(true);
  expect(logger.info)
    .toHaveBeenCalledWith(
      "User validated: Bob"
    );
});

3. Patterns de tests propres

Martin identifie plusieurs patterns qui rendent les tests propres et maintenables :

📏 Un concept par test

Chaque test vérifie une seule chose. Si le test échoue, on sait immédiatement quel concept est cassé.

🎯 FIRST principles

Fast (rapide), Independent (indépendant), Repeatable (reproductible), Self-validating (auto-validant), Timely (en temps voulu).

🏗️ Test Builders

Utiliser des builders pour créer des objets de test complexes. DRY appliqué aux données de test.

🎭 Fixtures réutilisables

Extraire les données de test communes dans des fixtures partagées mais modulables.

Pattern : Test Builders

❌ Duplication dans tests

test("calcul total", () => {
  const user = {
    id: 1,
    name: "Alice",
    email: "alice@ex.com",
    role: "admin",
    status: "active",
    createdAt: new Date()
  };
  // ...
});

test("validation email", () => {
  const user = {
    id: 2,
    name: "Bob",
    email: "bob@ex.com",
    role: "user",
    status: "active",
    createdAt: new Date()
  };
  // ...
});

// ⚠️ Duplication

✅ Test Builder pattern

// Builder réutilisable
class UserBuilder {
  private user: Partial<User> = {
    id: 1,
    name: "Test User",
    email: "test@ex.com",
    role: "user",
    status: "active",
    createdAt: new Date()
  };
  
  withName(name: string) {
    this.user.name = name;
    return this;
  }
  
  asAdmin() {
    this.user.role = "admin";
    return this;
  }
  
  build(): User {
    return this.user as User;
  }
}

// Usage dans tests
test("calcul total", () => {
  const user = new UserBuilder()
    .withName("Alice")
    .asAdmin()
    .build();
  // ...
});

test("validation email", () => {
  const user = new UserBuilder()
    .withName("Bob")
    .build();
  // ...
});

Pattern : Un concept par test

❌ Test fourre-tout

test("gestion utilisateur", () => {
  // Test création
  const user = createUser({
    name: "Alice"
  });
  expect(user.id).toBeDefined();
  
  // Test modification
  updateUser(user.id, {
    name: "Bob"
  });
  expect(user.name).toBe("Bob");
  
  // Test suppression
  deleteUser(user.id);
  expect(
    findUser(user.id)
  ).toBeNull();
  
  // ⚠️ 3 concepts en 1 test
  // Si échec, lequel ?
});

✅ Tests séparés

test("crée utilisateur", () => {
  const user = createUser({
    name: "Alice"
  });
  
  expect(user.id).toBeDefined();
  expect(user.name).toBe("Alice");
});

test("modifie utilisateur", () => {
  const user = aUser();
  
  updateUser(user.id, {
    name: "Bob"
  });
  
  expect(
    findUser(user.id).name
  ).toBe("Bob");
});

test("supprime utilisateur", () => {
  const user = aUser();
  
  deleteUser(user.id);
  
  expect(
    findUser(user.id)
  ).toBeNull();
});

// ✅ 1 concept = 1 test

4. Vitest & Testing Library

En TypeScript/React, Vitest + Testing Library sont les outils modernes pour appliquer les principes de Martin.

⚡ Vitest

Framework de test ultra-rapide compatible Vite. Syntaxe Jest, vitesse native.

import { test, expect } from 'vitest';

test("addition", () => {
  expect(1 + 1).toBe(2);
});

🎭 Testing Library

Tester comme un utilisateur, pas comme un développeur. Query par texte, rôle, label.

const button = screen
  .getByRole('button', {
    name: /submit/i
  });

await userEvent.click(button);

🔍 Queries prioritaires

Ordre de préférence : getByRole > getByLabelText > getByText > getByTestId (dernier recours).

⏱️ Async utilities

waitFor, findBy pour les opérations asynchrones. Ne jamais utiliser setTimeout dans tests.

const user = await screen
  .findByText(/alice/i);

await waitFor(() => {
  expect(api.fetch)
    .toHaveBeenCalled();
});

Exemple complet : Test de composant React

import { render, screen, waitFor } from 
  '@testing-library/react';
import userEvent from 
  '@testing-library/user-event';
import { test, expect, vi } from 'vitest';
import { UserProfile } from './UserProfile';

test("affiche profil utilisateur", 
  async () => {
  // ARRANGE
  const mockUser = {
    id: 1,
    name: "Alice",
    email: "alice@example.com"
  };
  
  const fetchUser = vi.fn()
    .mockResolvedValue(mockUser);
  
  // ACT
  render(
    <UserProfile 
      userId={1} 
      onFetch={fetchUser} 
    />
  );
  
  // ASSERT
  // Loading state
  expect(
    screen.getByText(/loading/i)
  ).toBeInTheDocument();
  
  // Données chargées
  const name = await screen.findByText(
    /alice/i
  );
  expect(name).toBeInTheDocument();
  
  expect(fetchUser)
    .toHaveBeenCalledWith(1);
});

test("gère erreur de chargement", 
  async () => {
  // ARRANGE
  const fetchUser = vi.fn()
    .mockRejectedValue(
      new Error("Network error")
    );
  
  // ACT
  render(
    <UserProfile 
      userId={1} 
      onFetch={fetchUser} 
    />
  );
  
  // ASSERT
  const error = await screen.findByText(
    /error/i
  );
  expect(error).toBeInTheDocument();
});

test("modification nom utilisateur", 
  async () => {
  // ARRANGE
  const user = userEvent.setup();
  const mockUser = aUser();
  const onUpdate = vi.fn();
  
  render(
    <UserProfile 
      user={mockUser}
      onUpdate={onUpdate}
    />
  );
  
  // ACT
  const input = screen.getByLabelText(
    /name/i
  );
  await user.clear(input);
  await user.type(input, "Bob");
  
  const saveButton = screen.getByRole(
    'button', 
    { name: /save/i }
  );
  await user.click(saveButton);
  
  // ASSERT
  await waitFor(() => {
    expect(onUpdate)
      .toHaveBeenCalledWith({
        ...mockUser,
        name: "Bob"
      });
  });
});

À Retenir — Chapitre 15

  • Tests = code de première classe. Même soin, même propreté que le code de production. Pas de compromis.
  • Tests sales = spirale de la mort. Tests ignorés → code fragile → bugs → perte de confiance → plus de tests sales.
  • Pattern AAA obligatoire. Arrange (30%) - Act (10%) - Assert (60%). Structure claire et prévisible.
  • Un concept par test. Si un test échoue, on doit savoir immédiatement quel comportement est cassé.
  • FIRST principles : Fast, Independent, Repeatable, Self-validating, Timely. 5 critères de qualité.
  • Test Builders pour DRY. Factoriser la création d'objets de test complexes. Réutilisabilité maximale.
  • Noms de tests explicites. "test 1" ❌ → "valide utilisateur actif avec email" ✅
  • Testing Library = user-centric. Tester comme un utilisateur : getByRole, getByText, pas getByClassName.
  • Async avec waitFor/findBy. Ne jamais utiliser setTimeout. Utilities async de Testing Library.
  • Refactorer les tests aussi. Quand le code de prod évolue, les tests doivent suivre avec la même qualité.

🎯 Exercice pratique : Prendre un fichier de test existant et appliquer le pattern AAA + Test Builder. Mesurer la réduction de duplication (objectif : -50% de lignes).