Hoe voeg je tests toe aan legacy code?

Question

Accepted Answer

**Legacy code** (vaak ongetest, moeilijk te wijzigen code) is uitdagend om te testen — het kan verwarde afhankelijkheden hebben en geen tests bevatten. Het veilig toevoegen van tests omvat technieken zoals **karakteriseringstests**, **seams** voor het doorbreken van afhankelijkheden, en incrementele verbetering, waardoor veiligere wijzigingen mogelijk worden.

## De uitdaging van legacy code

```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.
```

## Karakteriseringstests (huidige gedrag vastleggen)

```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.
```

## Afhankelijkheden doorbreken (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
```

## Incrementele aanpak

```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
```

## Waarom het belangrijk is

Begrijpen hoe je tests toevoegt aan legacy code is waardevol senior-niveau kennis omdat **het meeste werk in de echte wereld betreft bestaande, vaak ongetest code**, en het veilig verbeteren daarvan is een veel voorkomende, belangrijk uitdaging, dus het is praktisch relevant.

Legacy code (ongetest, strak gekoppeld, moeilijk te wijzigen) presenteert een echt **kip-en-ei-probleem**: om het veilig te wijzigen heb je tests nodig, maar het is moeilijk om te testen (verwarde afhankelijkheden, niet ontworpen voor testen) — en het wijzigen van ongetest code is gevaarlijk omdat je niet kunt zien of je iets hebt gebroken.

Begrijpen van de technieken om dit aan te pakken is waardevol praktisch kennis. **Karakteriseringstests** (het vastleggen van het *huidige* gedrag van de code zoals het is, stellend wat het werkelijk doet in plaats van wat het zou moeten doen — zelfs als dit niet volledig begrepen wordt) bieden een **veiligheidsnet** dat je in staat stelt om te refactoren en wijzigingen door te voeren met het vertrouwen dat bestaand gedrag behouden blijft — een sleuteltechniek voor het werken met code die je niet volledig begrijpt.

Begrijpen van het **doorbreken van afhankelijkheden via seams** (het vinden of creëren van plaatsen om afhankelijkheden te vervangen, met behulp van minimale veilige refactors om verwarde code testbaar te maken — de technieken uit Michael Feathers' werk over legacy code) is essentieel voor het onder controle brengen van moeilijk te testen code.

Begrijpen van de **incrementele aanpak** — het toevoegen van tests rond code voordat je deze wijzigt (een veiligheidsnet voor de wijziging), gericht op gebieden die worden gewijzigd of hoog risico/hoog waarde (niet de gehele codebase tegelijk), en incrementeel verbeteren (de boy scout regel) — weerspiegelt de pragmatische, realistische manier om legacy systemen in de loop van de tijd te verbeteren.

Omdat het meeste werk in de echte wereld betreft bestaande, vaak ongetest legacy code die veilig moet worden gewijzigd (een veel voorkomende, uitdagende situatie), en omdat het begrijpen van de technieken (karakteriseringstests voor een veiligheidsnet, seams voor het doorbreken van afhankelijkheden, incrementele verbetering) dit mogelijk maakt, is het begrijpen hoe je tests toevoegt aan legacy code waardevol senior-niveau kennis — praktisch relevant voor de alledaagse werkelijkheid van het werken met bestaande ongetest code, wat de ervaring en technieken weerspiegelt die nodig zijn om legacy systemen veilig te verbeteren, een belangrijk competentie voor senior engineers die regelmatig ongetest code veiliger moeten maken om wijzigingen door te voeren.