Chapitre 9 – Les Tests Unitaires

Clean Code — Chapitre 9 : Les Tests Unitaires

Le chapitre 9 est l'un des plus impactants du livre. Martin y démonte une idée reçue tenace : « les tests sont secondaires, on les écrit quand on a le temps ». Sa thèse : les tests ne sont pas moins importants que le code de production. Ils doivent être aussi propres, lisibles et maintenables. Un test sale est pire que pas de test du tout, car il devient un boulet qui ralentit toute évolution.

💡 L'idée clé du chapitre en une phrase :

« Les tests permettent le changement. Sans tests, chaque modification est un pari. Avec des tests propres, chaque modification est sûre. »

  • Les 3 lois du TDD — écrire le test avant le code de production, en cycles ultra-courts
  • Les tests doivent être propres — aussi lisibles que votre code métier
  • F.I.R.S.T. — 5 principes pour des tests de qualité (Fast, Independent, Repeatable, Self-validating, Timely)
  • Un seul concept par test — chaque test vérifie une seule règle métier
Le cycle TDD — Red → Green → Refactor 🔴 RED Écrire un test qui échoue 🟢 GREEN Faire passer le test (minimal) 🔵 REFACTOR Nettoyer le code (tests verts) Recommencer (nouveau test) ~30 sec ~2 min ~3 min

1. Les 3 lois du TDD (Test-Driven Development)

Martin est catégorique : le TDD n'est pas une option « nice-to-have », c'est une discipline professionnelle. Les 3 lois du TDD créent un cycle ultra-rapide où vous n'écrivez jamais de code de production sans test qui échoue d'abord.

1 Pas de code prod sans test qui échoue

Vous ne pouvez pas écrire une seule ligne de code de production tant qu'un test unitaire qui échoue ne le demande pas.

2 Écrire juste assez de test pour échouer

N'écrivez pas plus de test qu'il n'en faut pour voir un échec (compilation qui échoue = échec).

3 Écrire juste assez de code prod pour passer

N'écrivez pas plus de code de production qu'il n'en faut pour faire passer le test qui échoue actuellement.

🔵 Ce que ça change concrètement : Vous êtes en cycle Red → Green → Refactor toutes les 30 secondes à 2 minutes. Vous n'accumulez jamais plus de 5-10 lignes de code non testé. La couverture de test devient naturelle, pas un effort a posteriori.

⏱️ Exemple concret — TDD pour un validateur d'email (TypeScript)

// 🔴 RED — Étape 1 : écrire le test AVANT le code
describe("EmailValidator", () => {
  test("rejette une chaîne vide", () => {
    expect(isValidEmail("")).toBe(false);
  });
});

// ❌ Le test échoue : isValidEmail n'existe pas
// ────────────────────────────────────────────────────────

// 🟢 GREEN — Étape 2 : écrire JUSTE assez pour passer
export function isValidEmail(email: string): boolean {
  return email.length > 0; // implémentation minimale
}

// ✅ Le test passe maintenant
// ────────────────────────────────────────────────────────

// 🔴 RED — Étape 3 : nouveau test qui échoue
test("rejette un email sans @", () => {
  expect(isValidEmail("invalidemail")).toBe(false);
});

// ❌ Échoue : notre implémentation accepte "invalidemail"
// ────────────────────────────────────────────────────────

// 🟢 GREEN — Étape 4 : faire passer ce test
export function isValidEmail(email: string): boolean {
  return email.length > 0 && email.includes("@");
}

// ✅ Les deux tests passent
// ────────────────────────────────────────────────────────

// 🔵 REFACTOR — Étape 5 : nettoyer (tests toujours verts)
export function isValidEmail(email: string): boolean {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailRegex.test(email);
}

// ✅ Toujours vert, mais code plus propre et exhaustif

⚠️ Piège fréquent : vouloir implémenter la solution complète dès le premier test. Résistez à cette tentation. Le TDD vous force à y aller par petits pas — c'est ce qui garantit une couverture à 100% et un design émergent naturellement testable.

2. Tests propres — lisibilité avant tout

La règle centrale du chapitre : les tests doivent être aussi propres que le code de production. Un test sale (duplication, noms cryptiques, setups complexes) devient un boulet qui ralentit l'équipe. Quand le code métier change, personne ne veut toucher aux tests parce qu'ils sont incompréhensibles.

❌ Test sale — illisible

test("test user", () => {
const u = { 
n: "Alice", 
e: "a@x.com" 
};
const r = new UserRepo();
r.init();
r.add(u);
const f = r.find(u.e);
expect(f.n).toBe("Alice");
r.cleanup();
});
// ❌ Noms cryptiques (u, r, f)
// ❌ Setup/teardown manuel
// ❌ Intention floue

✅ Test propre — intention claire

describe("UserRepository", () => {
test("trouve utilisateur 
  par email", () => {
// Arrange
const alice = createUser({
name: "Alice",
email: "alice@ex.com"
});
repo.save(alice);

// Act
const found = 
repo.findByEmail(
  "alice@ex.com"
);

// Assert
expect(found).toEqual(alice);
});
});

🎯 Le principe #1 de Martin pour les tests

Lisibilité, lisibilité, lisibilité. Un test doit se lire comme une spécification métier. Quelqu'un qui ne connaît pas le code doit comprendre ce qui est testé en 10 secondes.

Le pattern AAA — Arrange, Act, Assert

Le pattern AAA (aussi appelé Given-When-Then) structure chaque test en 3 phases claires. C'est le standard de facto en TypeScript/React.

🎯 Pattern AAA appliqué en TypeScript

describe("ShoppingCart", () => {
test("calcule total avec réduction VIP", () => {
// ARRANGE — Préparer
const cart = new ShoppingCart();
const vipUser = createUser({ 
vip: true 
});
cart.addItem({ 
name: "Livre", 
price: 20 
});
cart.addItem({ 
name: "Stylo", 
price: 5 
});

// ACT — Exécuter l'action
const total = cart.calculateTotal(vipUser);

// ASSERT — Vérifier le résultat
expect(total).toBe(22.5); 
// 25 - 10% VIP = 22.5
});
});

📝 Version simplifiée (sans commentaires AAA)

test("applique la TVA française 20%", () => {
const order = createOrder({ 
subtotal: 100, 
country: "FR" 
});

const totalWithTax = 
order.calculateTotalWithTax();

expect(totalWithTax).toBe(120);
});

// Pattern AAA toujours présent,
// mais implicite car simple

3. Les principes F.I.R.S.T. — 5 qualités d'un bon test

Martin condense les qualités d'un test propre en 5 principes mémorisables avec l'acronyme F.I.R.S.T. :

F.I.R.S.T. — Les 5 piliers d'un bon test F — Fast (Rapide) Les tests doivent s'exécuter en millisecondes. Si lents → on ne les lance pas → inutiles. I — Independent (Indépendant) Aucun test ne dépend d'un autre. Peuvent s'exécuter dans n'importe quel ordre. R — Repeatable (Répétable) Même résultat à chaque exécution. Pas de dépendance réseau/date/random. S — Self-Validating (Auto-validant) Retourne true/false (pass/fail). Pas besoin de lire des logs pour savoir. T — Timely (Au bon moment) Écrits JUSTE AVANT le code de prod (TDD). Pas après coup (trop dur à tester après). 💡 Règle d'or Si vos tests violent un seul de ces principes, ils ne seront pas maintenus et perdront leur valeur.

🛠️ Violations fréquentes de F.I.R.S.T. en React — à éviter

// ❌ Viole FAST — appel réseau réel
test("récupère les utilisateurs", async () => {
  const users = await fetch("https://api.example.com/users"); // lent !
  expect(users).toHaveLength(10);
});

// ✅ FAST — mock du fetch
test("récupère les utilisateurs", async () => {
  vi.spyOn(global, "fetch").mockResolvedValue({
    json: async () => [{ id: 1, name: "Alice" }],
  });
  const users = await fetchUsers();
  expect(users).toHaveLength(1);
});

// ────────────────────────────────────────────────────────

// ❌ Viole INDEPENDENT — dépend d'un état partagé
let sharedCart: ShoppingCart;

test("ajoute un item", () => {
  sharedCart = new ShoppingCart();
  sharedCart.addItem({ name: "Livre", price: 20 });
  expect(sharedCart.items).toHaveLength(1);
});

test("calcule le total", () => {
  // ⚠️ Dépend du test précédent !
  expect(sharedCart.calculateTotal()).toBe(20);
});

// ✅ INDEPENDENT — chaque test crée son propre état
test("calcule le total avec un item", () => {
  const cart = new ShoppingCart();
  cart.addItem({ name: "Livre", price: 20 });
  expect(cart.calculateTotal()).toBe(20);
});

// ────────────────────────────────────────────────────────

// ❌ Viole REPEATABLE — dépend de la date actuelle
test("vérifie si l'offre est valide", () => {
  const offer = { expiresAt: "2025-12-31" };
  expect(isOfferValid(offer)).toBe(true); // ⚠️ échoue après 2025
});

// ✅ REPEATABLE — inject la date
test("vérifie si l'offre est valide", () => {
  const offer = { expiresAt: "2025-12-31" };
  const currentDate = new Date("2025-06-01");
  expect(isOfferValid(offer, currentDate)).toBe(true);
});

// ────────────────────────────────────────────────────────

// ❌ Viole SELF-VALIDATING — nécessite inspection manuelle
test("affiche le profil utilisateur", () => {
  render(<UserProfile userId="123" />);
  screen.debug(); // ⚠️ il faut lire la console pour valider
});

// ✅ SELF-VALIDATING — assertion automatique
test("affiche le nom de l'utilisateur", async () => {
  render(<UserProfile userId="123" />);
  expect(await screen.findByText("Alice Dupont")).toBeInTheDocument();
});

4. Un seul concept par test

Martin recommande : testez un seul concept par test. Cela ne signifie pas forcément « un seul expect() » — parfois plusieurs assertions vérifient le même concept. L'idée est que quand un test échoue, vous devez immédiatement savoir quel comportement métier est cassé.

❌ Test tentaculaire — plusieurs concepts

test("UserService", () => {
  const service = new UserService();
  
  // Concept 1 : création
  const user = service.create("Alice", "alice@x.com");
  expect(user.name).toBe("Alice");
  
  // Concept 2 : recherche
  const found = service.findByEmail("alice@x.com");
  expect(found).toBe(user);
  
  // Concept 3 : suppression
  service.delete(user.id);
  expect(service.findById(user.id)).toBeNull();
});
// ❌ Si ça échoue, on ne sait pas où
// ❌ Difficile à maintenir

✅ Un concept = un test

describe("UserService", () => {
  test("crée un utilisateur avec nom et email", () => {
    const user = service.create("Alice", "alice@x.com");
    expect(user.name).toBe("Alice");
    expect(user.email).toBe("alice@x.com");
  });

  test("trouve un utilisateur par email", () => {
    const user = service.create("Alice", "alice@x.com");
    const found = service.findByEmail("alice@x.com");
    expect(found).toEqual(user);
  });

  test("supprime un utilisateur existant", () => {
    const user = service.create("Alice", "alice@x.com");
    service.delete(user.id);
    expect(service.findById(user.id)).toBeNull();
  });
});
// ✅ Échec ciblé
// ✅ Facile à maintenir

🎯 La règle du nom de test

Si vous ne pouvez pas décrire votre test en une phrase claire (test("fait X quand Y")), c'est qu'il teste probablement trop de choses. Divisez-le.

5. Application concrète en React — Vitest + Testing Library

En React moderne, l'écosystème standard pour les tests unitaires est Vitest (pour la rapidité) + Testing Library (pour tester les composants comme un utilisateur). Voici comment appliquer les principes du chapitre 9.

Configuration Vitest — setup optimal

⚙️ Configuration Vitest pour un projet React + TypeScript

// vite.config.ts
import { defineConfig } from "vitest/config";
import react from "@vitejs/plugin-react";

export default defineConfig({
  plugins: [react()],
  test: {
    globals: true,              // describe, test, expect globaux
    environment: "jsdom",        // simuler le DOM
    setupFiles: "./src/setup-tests.ts",
    coverage: {
      provider: "v8",
      reporter: ["text", "html"],
      exclude: ["**/*.config.ts", "**/main.tsx"],
    },
  },
});

// src/setup-tests.ts — Configuration Testing Library
import "@testing-library/jest-dom/vitest";
import { cleanup } from "@testing-library/react";
import { afterEach, vi } from "vitest";

// Nettoyer après chaque test (principe INDEPENDENT)
afterEach(() => {
  cleanup();
  vi.clearAllMocks();
});

// Mock des services externes (principe REPEATABLE)
vi.mock("@/boundaries/http/AxiosHttpClient");
vi.mock("@/boundaries/analytics/MixpanelAnalytics");

Tester un composant React — bonnes pratiques

🧪 Test complet d'un composant — pattern AAA + user-centric

// components/UserCard.test.tsx
import { render, screen, waitFor } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { UserCard } from "./UserCard";
import { vi } from "vitest";

describe("UserCard", () => {
  // ✅ Helper pour éviter la duplication (principe DRY)
  const renderUserCard = (props = {}) => {
    const defaultProps = {
      userId: "123",
      onDelete: vi.fn(),
    };
    return render(<UserCard {...defaultProps} {...props} />);
  };

  test("affiche le nom et l'email de l'utilisateur", async () => {
    // Arrange
    renderUserCard();

    // Act — pas d'action, juste un rendu

    // Assert — vérifie ce que l'utilisateur VOIT
    expect(await screen.findByText("Alice Dupont")).toBeInTheDocument();
    expect(screen.getByText("alice@example.com")).toBeInTheDocument();
  });

  test("appelle onDelete quand le bouton est cliqué", async () => {
    // Arrange
    const user = userEvent.setup();
    const onDelete = vi.fn();
    renderUserCard({ onDelete });

    // Act
    const deleteButton = screen.getByRole("button", { name: /supprimer/i });
    await user.click(deleteButton);

    // Assert
    expect(onDelete).toHaveBeenCalledWith("123");
  });

  test("affiche un loader pendant le chargement", () => {
    // Arrange
    renderUserCard({ isLoading: true });

    // Act — pas d'action

    // Assert
    expect(screen.getByRole("status")).toBeInTheDocument();
    expect(screen.queryByText("Alice Dupont")).not.toBeInTheDocument();
  });

  test("affiche une erreur si le chargement échoue", () => {
    // Arrange
    const error = new Error("Utilisateur introuvable");
    renderUserCard({ error });

    // Act — pas d'action

    // Assert
    expect(screen.getByText(/erreur/i)).toBeInTheDocument();
    expect(screen.getByText(/utilisateur introuvable/i)).toBeInTheDocument();
  });
});

Tester un hook custom — isolation totale

🪝 Test d'un hook avec renderHook (Testing Library)

// hooks/useCounter.test.ts
import { renderHook, act } from "@testing-library/react";
import { useCounter } from "./useCounter";

describe("useCounter", () => {
  test("initialise à 0 par défaut", () => {
    const { result } = renderHook(() => useCounter());
    expect(result.current.count).toBe(0);
  });

  test("initialise avec une valeur custom", () => {
    const { result } = renderHook(() => useCounter(10));
    expect(result.current.count).toBe(10);
  });

  test("incrémente le compteur", () => {
    const { result } = renderHook(() => useCounter());
    
    act(() => {
      result.current.increment();
    });
    
    expect(result.current.count).toBe(1);
  });

  test("décrémente le compteur", () => {
    const { result } = renderHook(() => useCounter(5));
    
    act(() => {
      result.current.decrement();
    });
    
    expect(result.current.count).toBe(4);
  });

  test("reset remet à la valeur initiale", () => {
    const { result } = renderHook(() => useCounter(10));
    
    act(() => {
      result.current.increment();
      result.current.increment();
      result.current.reset();
    });
    
    expect(result.current.count).toBe(10);
  });
});

Mock des dépendances externes — principe REPEATABLE

🎭 Mocker proprement avec Vitest

// services/UserService.test.ts
import { describe, test, expect, vi, beforeEach } from "vitest";
import { UserService } from "./UserService";
import type { IHttpClient } from "@/boundaries/http/types";

describe("UserService", () => {
  let httpClient: IHttpClient;
  let userService: UserService;

  beforeEach(() => {
    // ✅ Créer un mock propre pour chaque test (INDEPENDENT)
    httpClient = {
      get: vi.fn(),
      post: vi.fn(),
      put: vi.fn(),
      delete: vi.fn(),
    };
    userService = new UserService(httpClient);
  });

  test("récupère un utilisateur par ID", async () => {
    // Arrange
    const mockUser = { id: "123", name: "Alice", email: "alice@x.com" };
    vi.mocked(httpClient.get).mockResolvedValue(mockUser);

    // Act
    const user = await userService.getUser("123");

    // Assert
    expect(httpClient.get).toHaveBeenCalledWith("/users/123");
    expect(user).toEqual(mockUser);
  });

  test("lance une erreur si l'utilisateur n'existe pas", async () => {
    // Arrange
    vi.mocked(httpClient.get).mockRejectedValue(
      new Error("404 Not Found")
    );

    // Act & Assert
    await expect(userService.getUser("999")).rejects.toThrow("404 Not Found");
  });
});

Tableau récapitulatif — types de tests en React

Type de test Quoi tester Outil Principe F.I.R.S.T. critique
Composant UI Ce que l'utilisateur voit et fait Testing Library Self-Validating
Hook custom Logique de state isolée renderHook Independent
Service/Util Logique métier pure Vitest seul Fast
Intégration Flux complet (composant + hooks + services) Testing Library + mocks Repeatable

✅ Checklist pour un test React propre :

  • Nom explicite : test("affiche une erreur si l'email est invalide")
  • Pattern AAA visible (commentaires optionnels si évident)
  • Un seul concept testé (un comportement métier)
  • Pas de duplication : helpers renderWithProviders(), createMockUser()
  • Mocks isolés : beforeEach(() => vi.clearAllMocks())
  • Assertions user-centric : screen.getByRole(), pas container.querySelector()
  • Pas d'attente arbitraire : await screen.findBy...(), pas setTimeout()

À Retenir — Chapitre 9 Clean Code

  • Les 3 lois du TDD — Jamais de code prod sans test qui échoue. Cycle ultra-court (30 sec–2 min) : Red → Green → Refactor.
  • Tests = code de première classe — Aussi propres, lisibles et maintenables que le code de production. Un test sale est pire que pas de test.
  • Pattern AAA — Arrange, Act, Assert. Chaque test se lit comme une spécification métier claire.
  • F.I.R.S.T. — Fast (rapide), Independent (indépendant), Repeatable (répétable), Self-validating (auto-validant), Timely (au bon moment).
  • Un seul concept par test — Quand un test échoue, vous devez immédiatement savoir quel comportement métier est cassé.
  • En React : Vitest + Testing Library — Tester ce que l'utilisateur voit/fait, pas les détails d'implémentation. screen.getByRole() > querySelector().
  • Mocks propres — Isoler les dépendances externes (API, date, random). Chaque test crée son propre état (principe Independent).
  • Helpers et factories — createMockUser(), renderWithProviders() pour éliminer la duplication dans les tests.

⏱️ Temps pour adopter ces pratiques : ~1 semaine pour habituer l'équipe au TDD strict, ~3 jours pour refactorer les tests existants selon F.I.R.S.T. Sur un nouveau projet : TDD dès le début = zéro effort de rattrapage.