Testgetriebene Entwicklung
Philosophie
Kernprinzip: Tests sollten Verhalten über öffentliche Schnittstellen validieren, nicht über Implementierungsdetails. Code kann sich vollständig ändern; Tests sollten das nicht.
Gute Tests sind integrationsstilartig: Sie üben echte Codepfade über öffentliche APIs aus. Sie beschreiben, was das System tut, nicht wie es das tut. Ein guter Test liest sich wie eine Spezifikation – „Benutzer kann mit gültigem Warenkorb zur Kasse gehen“ sagt Ihnen genau, welche Fähigkeit existiert. Diese Tests überleben Refactorings, weil sie sich nicht um die interne Struktur kümmern.
Schlechte Tests sind an die Implementierung gekoppelt. Sie mocken interne Kollaborateure, testen private Methoden oder verifizieren über externe Mittel (wie direktes Abfragen einer Datenbank anstatt die Schnittstelle zu verwenden). Das Warnsignal: Ihr Test bricht beim Refactoring, obwohl sich das Verhalten nicht geändert hat. Wenn Sie eine interne Funktion umbenennen und Tests fehlschlagen, haben diese Tests die Implementierung getestet, nicht das Verhalten.
Siehe tests.md für Beispiele und mocking.md für Richtlinien zum Mocken.
Anti-Pattern: Horizontale Schnitte
Schreiben Sie NICHT zuerst alle Tests, dann die gesamte Implementierung. Das ist „horizontales Slicing“ – ROT als „alle Tests schreiben“ und GRÜN als „allen Code schreiben“ zu behandeln.
Das erzeugt miese Tests:
- Tests, die in großen Mengen geschrieben werden, testen vorgestelltes Verhalten, nicht tatsächliches Verhalten
- Sie testen am Ende die Struktur von Dingen (Datenstrukturen, Funktionssignaturen) anstatt das benutzerseitige Verhalten
- Tests werden unempfindlich gegenüber echten Änderungen – sie bestehen, wenn das Verhalten bricht, und schlagen fehl, wenn das Verhalten in Ordnung ist
- Sie überholen Ihre eigene Erkenntnis, indem Sie sich vor dem Verständnis der Implementierung auf eine Teststruktur festlegen
Korrekte Herangehensweise: Vertikale Schnitte mittels Tracer Bullets. Ein Test → eine Implementierung → wiederholen. Jeder Test reagiert auf das, was Sie aus dem vorherigen Zyklus gelernt haben. Da Sie gerade den Code geschrieben haben, wissen Sie genau, welches Verhalten wichtig ist und wie Sie es verifizieren können.
FALSCH (horizontal):
ROT: test1, test2, test3, test4, test5
GRÜN: impl1, impl2, impl3, impl4, impl5
RICHTIG (vertikal):
ROT→GRÜN: test1→impl1
ROT→GRÜN: test2→impl2
ROT→GRÜN: test3→impl3
...
Arbeitsablauf
1. Planung
Beim Erkunden der Codebasis lesen Sie CONTEXT.md (falls vorhanden), damit Testnamen und Schnittstellenvokabular mit der Domänensprache des Projekts übereinstimmen, und respektieren Sie ADRs in dem Bereich, den Sie bearbeiten.
Bevor Sie Code schreiben:
- Mit dem Benutzer bestätigen, welche Schnittstellenänderungen erforderlich sind
- Mit dem Benutzer bestätigen, welche Verhaltensweisen zu testen sind (Priorisierung)
- Möglichkeiten für tiefe Module identifizieren (kleine Schnittstelle, tiefe Implementierung) – führen Sie die Fähigkeit
/codebase-designfür das Vokabular und die Testbarkeitsprüfungen aus - Die zu testenden Verhaltensweisen auflisten (nicht Implementierungsschritte)
- Zustimmung des Benutzers zum Plan einholen
Fragen Sie: „Wie sollte die öffentliche Schnittstelle aussehen? Welche Verhaltensweisen sind am wichtigsten zu testen?“
Sie können nicht alles testen. Bestätigen Sie mit dem Benutzer genau, welche Verhaltensweisen am wichtigsten sind. Konzentrieren Sie den Testaufwand auf kritische Pfade und komplexe Logik, nicht auf jeden möglichen Randfall.
2. Tracer Bullet
Schreiben Sie EINEN Test, der EINE Sache über das System bestätigt:
ROT: Test für das erste Verhalten schreiben → Test schlägt fehl
GRÜN: Minimalen Code schreiben, um zu bestehen → Test besteht
Dies ist Ihr Tracer Bullet – beweist, dass der Pfad durchgängig funktioniert.
3. Inkrementelle Schleife
Für jedes verbleibende Verhalten:
ROT: Nächsten Test schreiben → schlägt fehl
GRÜN: Minimaler Code, um zu bestehen → besteht
Regeln:
- Ein Test nach dem anderen
- Nur genug Code, um den aktuellen Test zu bestehen
- Zukünftige Tests nicht vorwegnehmen
- Tests auf beobachtbares Verhalten konzentrieren
4. Refactoring
Nachdem alle Tests bestanden sind, nach Refactoring-Kandidaten suchen:
- Duplikate extrahieren
- Module vertiefen (Komplexität hinter einfache Schnittstellen verschieben)
- SOLID-Prinzipien anwenden, wo natürlich
- Überlegen, was neuer Code über bestehenden Code verrät
- Tests nach jedem Refactoring-Schritt ausführen
Nie während ROT refaktorieren. Zuerst zu GRÜN gelangen.
Checkliste Pro Zyklus
[ ] Test beschreibt Verhalten, nicht Implementierung
[ ] Test verwendet nur öffentliche Schnittstelle
[ ] Test würde internes Refactoring überleben
[ ] Code ist minimal für diesen Test
[ ] Keine spekulativen Funktionen hinzugefügt