Wie fügt man Tests zu Legacy-Code hinzu?

Question

Accepted Answer

**Legacy-Code** (oft ungetesteter, schwer zu ändernder Code) ist schwierig zu testen – er kann verschachtelte Abhängigkeiten haben und keine Tests aufweisen. Das sichere Hinzufügen von Tests beinhaltet Techniken wie **Charakterisierungstests**, **Seams** zum Brechen von Abhängigkeiten und inkrementelle Verbesserung, die sicherere Änderungen ermöglichen.

## Herausforderung mit 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.
```

## Charakterisierungstests (aktuelles Verhalten festhalten)

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

## Abhängigkeiten brechen (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
```

## Inkrementeller Ansatz

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

## Warum es wichtig ist

Zu verstehen, wie man Tests zu Legacy-Code hinzufügt, ist wertvolles Knowledge auf Senior-Level, weil **die meiste reale Arbeit existierenden, oft ungetesteten Code betrifft** und ihn sicher zu verbessern ist eine häufige, wichtige Herausforderung, daher praktisch relevant.

Legacy-Code (ungetestet, eng gekoppelt, schwer zu ändern) stellt ein echtes **Huhn-Ei-Problem** dar: Um ihn sicher zu ändern, benötigen Sie Tests, aber es ist schwierig, ihn zu testen (verschachtelte Abhängigkeiten, nicht für Tests ausgelegt) – und ungetesteten Code zu ändern ist gefährlich, weil Sie nicht erkennen können, ob Sie etwas zerstört haben.

Die Techniken dafür zu verstehen ist wertvolles praktisches Wissen. **Charakterisierungstests** (das *aktuelle* Verhalten des Codes erfassen, asserten was er tatsächlich tut statt was er sollte – auch wenn nicht vollständig verstanden) bieten ein **Sicherheitsnetz**, das es Ihnen ermöglicht, mit Vertrauen umzugestalten und zu ändern, dass existierendes Verhalten erhalten bleibt – eine Schlüsseltechnik für die Arbeit mit Code, den Sie nicht vollständig verstehen.

Die Techniken zu verstehen **Abhängigkeiten via Seams zu brechen** (Stellen finden oder schaffen um Abhängigkeiten zu ersetzen, minimale sichere Umgestaltungen nutzen um verschachtelte Code testbar zu machen – die Techniken aus Michael Feathers' Arbeit zu Legacy-Code) ist essentiell, um schwer zu testenden Code unter Test zu bekommen.

Den **inkrementellen Ansatz** zu verstehen – Tests um Code hinzufügen bevor man ihn ändert (ein Sicherheitsnetz für die Änderung), sich auf Bereiche konzentrieren die geändert werden oder hohe Risiken/hohen Wert haben (nicht das ganze Codebase auf einmal), und inkrementell verbessern (die Boy Scout Regel) – spiegelt die pragmatische, realistische Weise wider Legacy-Systeme über Zeit zu verbessern.

Da die meiste reale Entwicklung existierenden, oft ungetesteten Legacy-Code betrifft der sicher geändert werden muss (eine häufige, herausfordernde Situation), und da das Verstehen der Techniken (Charakterisierungstests für ein Sicherheitsnetz, Seams um Abhängigkeiten zu brechen, inkrementelle Verbesserung) dies ermöglicht, ist das Verstehen wie man Tests zu Legacy-Code hinzufügt wertvolles Senior-Level-Wissen – praktisch relevant für die häufige Realität der Arbeit mit existierendem ungetesteten Code, spiegelnd die Erfahrung und Techniken die benötigt werden um Legacy-Systeme sicher zu verbessern, eine wichtige Kompetenz für Senior-Engineers die häufig ungetesteten Code sicherer zu ändern machen müssen.