Comment ajouter des tests au code legacy ?

Question

Accepted Answer

**Le code legacy** (souvent non testé, difficile à modifier) est un défi à tester — il peut avoir des dépendances enchevêtrées et pas de tests. Ajouter des tests de façon sécurisée implique des techniques comme les **tests de caractérisation**, les **seams** pour casser les dépendances, et l'amélioration incrémentale, permettant des modifications plus sûres.

## Le défi du code legacy

```text
Legacy code is often: untested, tightly coupled, hard to understand, risky to change:
  → no tests → changing it is dangerous (you can't tell if you broke something)
  → hard to test → dependencies are tangled (can't isolate units); not designed for testing
→ a chicken-and-egg problem: to change safely you need tests, but it's hard to test.
```

## Tests de caractérisation (verrouiller le comportement actuel)

```text
CHARACTERIZATION (golden master) tests → capture the code's CURRENT behavior as-is
  (even if you don't fully understand it / it has bugs):
  → write tests asserting what it ACTUALLY does now → a SAFETY NET
  → then you can refactor/change with confidence that behavior is preserved
→ Don't assert what it SHOULD do — assert what it DOES, to protect against regressions.
```

## Casser les dépendances (seams)

```text
To isolate hard-to-test code, find/create SEAMS (places to substitute dependencies):
  → extract dependencies behind interfaces; inject them; use the smallest safe refactors
    to make code testable (Michael Feathers' techniques)
  → carefully break dependencies so you can get the code under test, then test, then refactor
```

## Approche incrémentale

```text
✓ Add tests AROUND code BEFORE changing it (a safety net for the change)
✓ Focus on areas you're CHANGING / high-risk / high-value (not the whole codebase at once)
✓ Improve incrementally — leave code a bit better each time (the "boy scout rule")
✓ Use characterization tests to capture behavior, then refactor toward testability
```

## Pourquoi c'est important

Comprendre comment ajouter des tests au code legacy est une connaissance précieuse de niveau senior car **la plupart du travail réel implique du code existant, souvent non testé**, et l'améliorer de façon sécurisée est un défi courant et important, donc c'est pratiquement pertinent.

Le code legacy (non testé, fortement couplé, difficile à modifier) présente un véritable **problème de l'œuf et la poule** : pour le modifier de façon sécurisée, vous avez besoin de tests, mais c'est difficile à tester (dépendances enchevêtrées, non conçu pour les tests) — et modifier du code non testé est dangereux car vous ne pouvez pas savoir si vous avez cassé quelque chose.

Comprendre les techniques pour résoudre cela est une connaissance pratique précieuse. Les **tests de caractérisation** (capturant le comportement *actuel* du code tel quel, affirmant ce qu'il fait réellement plutôt que ce qu'il devrait faire — même s'il n'est pas complètement compris) fournissent un **filet de sécurité** qui vous permet de refactoriser et de modifier en confiance que le comportement existant est préservé — une technique clé pour travailler avec du code que vous ne comprenez pas entièrement.

Comprendre **casser les dépendances via les seams** (trouver ou créer des endroits pour substituer des dépendances, utilisant des refactorisations sûres minimales pour rendre le code enchevêtré testable — les techniques du travail de Michael Feathers sur le code legacy) est essentiel pour mettre du code difficile à tester sous test.

Comprendre l'**approche incrémentale** — ajouter des tests autour du code avant de le modifier (un filet de sécurité pour la modification), en se concentrant sur les zones modifiées ou à haut risque/haute valeur (pas l'ensemble du codebase à la fois), et améliorer incrementalement (la règle du boy scout) — reflète la façon pragmatique et réaliste d'améliorer les systèmes legacy au fil du temps.

Car la plupart du développement réel implique du code legacy existant, souvent non testé, qui doit être modifié de façon sécurisée (une situation courante et difficile), et car comprendre les techniques (tests de caractérisation pour un filet de sécurité, seams pour casser les dépendances, amélioration incrémentale) permet de faire cela, comprendre comment ajouter des tests au code legacy est une connaissance précieuse de niveau senior — pratiquement pertinente pour la réalité courante de travailler avec du code existant non testé, reflétant l'expérience et les techniques nécessaires pour améliorer de façon sécurisée les systèmes legacy, une compétence importante pour les ingénieurs senior qui doivent fréquemment rendre le code non testé plus sûr à modifier.