Qu'est-ce que les mocks, les stubs et les test doubles ?

Question

Accepted Answer

Les **test doubles** sont des objets qui remplacent les vraies dépendances dans les tests — y compris les **mocks**, les **stubs**, les **spies**, les **fakes** et les **dummies**. Ils isolent le code testé de ses dépendances (bases de données, APIs, services), permettant des tests unitaires rapides, ciblés et contrôlés.

## Pourquoi c'est important

```text
To test a unit in ISOLATION, replace its real dependencies (DB, API, services) with
TEST DOUBLES (fake stand-ins):
  → isolate the unit (test ONLY it, not its dependencies)
  → FAST (no real DB/network); CONTROLLED (set up exact scenarios, including errors);
    DETERMINISTIC (no external flakiness)
```

## Les types de test doubles

```text
STUB → provides canned RESPONSES to calls (returns preset data):
  → "when getUser is called, return this fake user" — controls inputs to the unit
MOCK → a stub that also VERIFIES interactions (was it called? how? with what?):
  → "verify save() was called once with these arguments" — checks behavior/interactions
SPY → wraps a real (or fake) object and RECORDS calls (verify how it was used)
FAKE → a working but simplified implementation (e.g. an in-memory database)
DUMMY → a placeholder passed but not actually used
```

```js
// stub: control what a dependency returns
const userService = { getUser: jest.fn().mockReturnValue({ name: 'Ann' }) };
// mock verification: check an interaction happened
expect(emailService.send).toHaveBeenCalledWith('ann@x.com');
```

## Mock vs stub (la distinction clé)

```text
STUB → controls INPUTS (provides data the unit needs) — "state" verification
MOCK → verifies OUTPUTS/interactions (was the dependency called correctly?) — "behavior"
  verification
→ Use stubs to provide data; mocks to verify the unit called a dependency correctly.
⚠️ Over-mocking → tests coupled to implementation (brittle); mock at the right boundaries.
```

## Pourquoi c'est important

Comprendre les test doubles (mocks, stubs, etc.) est important car ils sont **essentiels pour écrire des tests unitaires isolés**, c'est donc une connaissance de test précieuse et fréquemment appliquée.

Pour tester une unité en isolation (l'objectif du test unitaire), vous devez remplacer ses vraies dépendances (bases de données, APIs, services) par des **test doubles** — permettant des tests qui sont **rapides** (pas d'E/S réelle), **contrôlés** (mise en place de scénarios exacts incluant les conditions d'erreur difficiles à déclencher avec les vraies dépendances) et **déterministes** (pas d'instabilité externe).

Comprendre les **types** et leurs objectifs est nécessaire : les **stubs** (fournir des réponses figées pour contrôler ce que les dépendances retournent — alimenter l'unité avec des données spécifiques), les **mocks** (des stubs qui vérifient aussi les interactions — vérifier que l'unité a appelé une dépendance correctement), les **spies** (enregistrer les appels sur des objets réels ou faux), les **fakes** (implémentations simplifiées fonctionnelles comme les bases de données en mémoire) et les **dummies** (espaces réservés).

Comprendre la **distinction clé mock-vs-stub** — les stubs contrôlent les entrées (vérification d'état : fournir des données) tandis que les mocks vérifient les sorties/interactions (vérification de comportement : vérifier que l'unité a appelé les dépendances correctement) — est une connaissance conceptuelle importante souvent confuse, et utiliser chacun de manière appropriée importe.

Comprendre le **piège de la sur-mocking** (le mocking excessif couple les tests aux détails d'implémentation, les rendant fragiles, donc vous devez mocker aux bonnes limites) reflète un jugement de test mature.

Les test doubles sont utilisés constamment dans les tests unitaires pour isoler le code testé.

Étant donné que le test unitaire isolé nécessite de remplacer les vraies dépendances par des test doubles (pour la vitesse, le contrôle et le déterminisme), et étant donné que comprendre les types, la distinction mock-vs-stub et le piège de la sur-mocking est nécessaire pour écrire de bons tests isolés, comprendre les test doubles est une connaissance de test précieuse et fréquemment appliquée — essentielle pour les tests unitaires, utilisée constamment pour isoler le code testé et importante pour écrire des tests ciblés et contrôlés tout en évitant la fragilité de la sur-mocking, une compétence fondamentale pour des tests unitaires efficaces.