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.
⚠️ 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é.
❌ 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).