Testgetriebene Entwicklung
Kernprinzip
Verhaltensänderung verdient Vertrauen nur, wenn ein Test zuerst aus dem richtigen Grund fehlschlug und dann aufgrund der Implementierung bestanden hat.
Tests sollten Verhalten über öffentliche Schnittstellen verifizieren, nicht über Implementierungsdetails. Code kann sich komplett ändern; Tests sollten das nicht.
Gute Tests sind integrativ: Sie durchlaufen echte Codepfade über öffentliche APIs. 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, überprüfen Aufrufzahlen oder verifizieren über externe Mittel statt über die öffentliche Schnittstelle. Warnsignal: Der Test bricht nach einem Refactoring, obwohl das Verhalten gleich geblieben ist.
Siehe tests.md, mocking.md und testing-anti-patterns.md.
Eherne Regel
Keine eigene Produktionsverhaltensänderung ohne einen zuvor fehlschlagenden Test.
Bedeutung:
- Schreiben Sie einen Test für ein Verhalten.
- Führen Sie ihn aus und beobachten Sie seinen Fehlschlag.
- Bestätigen Sie, dass der Fehlschlag das fehlende Verhalten beweist, nicht einen Tippfehler oder Setup-Fehler.
- Schreiben Sie die kleinste Produktionsänderung, die den Test bestehen lässt.
- Refactorn Sie erst, wenn der Test grün ist.
Wenn bereits Implementierungscode vor dem Test existiert:
- Löschen Sie keine Benutzerarbeit ohne Erlaubnis.
- Behandeln Sie ihn als Spike/Referenz, nicht als validierte Implementierung.
- Bevorzugen Sie, ihn beiseite zu legen, den fehlschlagenden Test zu schreiben und dann vom Test aus zu implementieren.
- Wenn die Erhaltung des bestehenden Codes notwendig ist, fügen Sie zuerst einen Regression-/Charakterisierungstest hinzu, dann ändern Sie das Verhalten mit einem neuen fehlschlagenden Test.
Anti-Pattern: Horizontale Slices
Schreiben Sie nicht zuerst alle Tests und dann die gesamte Implementierung. Das sind horizontale Slices.
Falsch:
ROT: test1, test2, test3, test4
GRÜN: impl1, impl2, impl3, impl4
Richtig:
ROT -> GRÜN -> REFACTOR: Verhalten 1
ROT -> GRÜN -> REFACTOR: Verhalten 2
ROT -> GRÜN -> REFACTOR: Verhalten 3
Warum: Massentests kodieren ein erdachtes Design, entziehen sich dem Feedback und testen oft Formen statt Verhalten.
Arbeitsablauf
1. Verhalten planen
Bevor Sie Code schreiben:
- Bestätigen Sie Änderungen an der öffentlichen Schnittstelle mit dem Benutzer, wenn sie nicht offensichtlich sind.
- Listen Sie die zu testenden Verhaltensweisen auf, nicht die Implementierungsschritte.
- Priorisieren Sie kritische Pfade und komplexe Logik; jagen Sie keiner falschen Vollständigkeit hinterher.
- Identifizieren Sie Möglichkeiten für tiefe Module.
- Entwerfen Sie Schnittstellen für Testbarkeit.
- Wählen Sie das erste Tracer-Bullet-Verhalten.
Fragen Sie: „Welches öffentliche Verhalten muss existieren? Welches Verhalten ist zuerst wichtig?“
2. ROT: Ein fehlschlagender Test
Schreiben Sie einen minimalen Test für ein beobachtbares Verhalten.
Anforderungen:
- Verwendet nur die öffentliche Schnittstelle.
- Der Name beschreibt das Verhalten.
- Testet echten Code, wo praktikabel.
- Mockt nur an Systemgrenzen oder unvermeidbaren Nahtstellen.
- Schlägt vor der Implementierung fehl.
Führen Sie den engsten nützlichen Befehl aus, zum Beispiel:
npm test pfad/zu/test.test.ts
Überprüfen Sie den Fehlschlag:
- Der Test schlägt fehl, nicht die Einrichtung wegen Tippfehlern.
- Der Fehlergrund stimmt mit dem fehlenden Verhalten überein.
- Wenn er sofort bestanden wird, ist der Test falsch oder das Verhalten existiert bereits. Korrigieren Sie den Test oder wählen Sie das nächste fehlende Verhalten.
3. GRÜN: Minimale Implementierung
Schreiben Sie nur genug Code, um den aktuellen Test zu bestehen.
Tun Sie nicht:
- Spekulative Funktionen hinzufügen.
- Unzusammenhängenden Code refactorn.
- Zukünftige Optionen hinzufügen.
- Den Umfang erweitern, weil es „gerade nebenbei einfach ist“.
Führen Sie aus:
npm test pfad/zu/test.test.ts
Führen Sie dann relevante umliegende Tests aus. Die Ausgabe sollte sauber sein: keine neuen Warnungen, Flakes oder versteckten Fehler.
4. REFACTOR: Aufräumen, während es grün ist
Refactorn Sie erst, nachdem die Tests bestanden wurden. Wenn kein Refactoring sinnvoll ist, sagen Sie es kurz und fahren Sie fort.
Achten Sie auf Refactoring-Kandidaten:
- Duplikate
- Schlechte Namen
- Flache Module
- Unklare Grenzen
- Komplexität, die hinter einer kleinen Schnittstelle verborgen werden kann
Regeln:
- Verhalten und Erwartungen ändern sich nicht.
- Tests bleiben nach jedem Refactoring-Schritt grün.
- Test-Refactorings können umbenennen, deduplizieren, Fixtures/Builder extrahieren oder Fehlermeldungen verbessern.
- Wenn eine Assertion das erwartete Verhalten ändert, stoppen Sie: Das ist ein neuer ROT-Zyklus.
5. Vertikal wiederholen
Wählen Sie das nächste Verhalten basierend auf dem, was der letzte Zyklus gelehrt hat. Ein Verhalten nach dem anderen.
Checkliste pro Zyklus
[ ] Test beschreibt beobachtbares Verhalten, nicht Implementierung
[ ] Test verwendet nur öffentliche Schnittstelle
[ ] Test ist vor der Implementierung fehlgeschlagen
[ ] Fehlergrund war korrekt
[ ] Code ist minimal für diesen Test
[ ] Kein spekulatives Verhalten hinzugefügt
[ ] Relevante Tests bestehen sauber
[ ] Refactoring nur erwogen, während es grün ist
Commit-Gates
Für nachvollziehbare Arbeit committen Sie Phasen getrennt, wenn praktikabel:
- ROT-Commit: Nur Test oder minimales Gerüst plus fehlschlagende Assertion. Body zeichnet fehlschlagenden Befehl und Grund auf.
- GRÜN-Commit: Minimale Implementierung. Body zeichnet bestandenen gezielten Test und erwogenes Refactoring auf.
- REFACTOR-Commit: Keine Verhaltens- oder Erwartungsänderung. Body gibt an, was sich geändert hat und was unverändert geblieben ist.
Fügen Sie keine KI-Zuschreibungen in Commits ein.
CLI-Vertragstests
Bei CLI-Tools ist die Kommandooberfläche der Produktvertrag. Bevorzugen Sie Outside-In-Tests auf der niedrigsten zuverlässigen Ebene:
- CLI-Vertragstests: Führen Sie Root-/Subkommandos mit gefälschten Anbietern oder Fixtures aus; überprüfen Sie stdout, stderr, Exit-Verhalten, JSON-Struktur.
- Unit-Tests: Parsen, Vergleiche, Klassifikation, Kontextauswahl, Fehlerklassifikation.
- Provider-Integrationstests: Dateisystem-Fixtures und gefälschte externe Dienste; kein Netzwerk/Auth.
- Live-Smoke-Tests: Nur opt-in; überprüfen Sie Struktur/Invarianten, nicht volatile genaue Ausgabe.
Manuelle QA-Regression-Regel
Manuelles QA dient der Entdeckung, nicht als Validierungsrückgrat. Wenn es eine Verhaltenslücke findet:
- Schreiben Sie den niedrigstufigen ROT-Regressionstest, der sie reproduziert.
- Überprüfen Sie die Fehlschlagsnachweise.
- Implementieren Sie GRÜN.
- Führen Sie automatisierte Tests erneut aus.
- Führen Sie manuelles QA erst nach bestandenen Tests erneut aus.
Wenn sich die Ausgabe/der CLI-Aufbau geändert hat, fügen Sie einen CLI-Vertragstest hinzu oder aktualisieren Sie ihn.
Rationalisierungsfallen
| Behauptung | Antwort |
|---|---|
| „Zu einfach zum Testen“ | Einfaches Verhalten kann trotzdem regredieren. Fügen Sie den kleinen Test hinzu. |
| „Ich teste später“ | Später bestandene Tests beweisen nicht, dass der Test fehlschlagen kann. |
| „Ich habe es manuell überprüft“ | Manuelle Prüfungen sind keine wiederholbaren Regressionstests. |
| „Ich muss zuerst explorieren“ | In Ordnung. Spiken, dann beiseite legen und mit TDD beginnen. |
| „Test ist schwer“ | Die Schnittstelle ist möglicherweise schwer zu verwenden. Vereinfachen Sie die Nahtstelle/das Design. |
| „Mocken macht es einfach“ | Vielleicht wird Mock-Verhalten getestet. Lesen Sie Anti-Patterns. |
| „Ein großer Test deckt es ab“ | Bevorzugen Sie ein Verhalten pro Test, es sei denn, ein End-to-End-Vertrag erfordert mehr. |
| „Refactoring braucht einen fehlschlagenden Test“ | Reines Refactoring startet grün und bleibt grün; Verhaltensänderung braucht ROT. |
Rote Flaggen: Stoppen und korrigieren
- Produktionsverhalten geändert vor fehlschlagendem Test.
- Test besteht sofort, wird aber als ROT bezeichnet.
- Fehlergrund nicht untersucht.
- Testname beschreibt Implementierung.
- Test überprüft private Aufrufe, Aufrufreihenfolge oder interne Kollaborateure.
- Mock-Logik dominiert die Testlogik.
- Neue Methode existiert nur für Tests.
- Test während GRÜN korrigiert, weil die Implementierung widerspricht.
- Horizontale Stapel von Tests vor jeglicher Implementierung.
Wenn Sie feststecken
| Problem | Vorgehen |
|---|---|
| Weiß nicht, wie testen | Schreiben Sie die gewünschte öffentliche API und die erste Assertion. |
| Test-Setup riesig | Extrahiere Fixture/Helper; wenn immer noch riesig, Design vereinfachen. |
| Muss alles mocken | Code ist wahrscheinlich zu stark gekoppelt. Dependency Injection/Nahtstelle einführen. |
| Vorhandener Code hat keine Tests | Charakterisierungstest für aktuelles Verhalten hinzufügen, dann ROT für Änderung. |
| Fehler unklar | Manuell mit Logs reproduzieren, dann kleinsten fehlschlagenden Regressionstest kodieren. |
Überprüfung vor Fertigstellung
- Neues/geändertes Verhalten hat Tests.
- Jeder neue Verhaltenstest wurde beim Fehlschlagen aus dem richtigen Grund beobachtet.
- Alle relevanten Tests bestehen.
- Tests verifizieren öffentliches Verhalten.
- Mocks sind nur grenzständig oder gerechtfertigt.
- Keine test-only Produktions-APIs hinzugefügt.
- Manuelle QA-Erkenntnisse wurden zu Regressionstests.