Test-Driven Development: Was TDD für die Softwarequalität leistet

TDD entmystifiziert: Vorteile, Grenzen und Studienlage für Entwicklerteams
Aktualisiert:
Abstract
- #Test-Driven Development
- #TDD
- #Softwarequalität
- #Softwareentwicklung
- #Agile Methoden
- #Unit Testing
- #Continuous Integration
- #Refactoring
Von Rot zu Grün: Wie das Schreiben der Tests vor dem Code Design und Fehlerquote verändert
Ein Entwickler soll im Webshop die Versandkostenregel ändern: Ab 50 Euro Warenwert ist der Versand künftig kostenlos statt ab 60 Euro. Eine Zeile Code, schnell erledigt. Zwei Wochen später fällt auf, dass seitdem auch Bestellungen ins Ausland versandkostenfrei sind. Niemand hatte diese Ausnahme schriftlich festgehalten, und kein automatischer Test hat Alarm geschlagen.
Test-Driven Development, kurz TDD, setzt genau hier an. Die Methode dreht die gewohnte Reihenfolge um: Erst beschreibt ein Test, was der Code leisten soll, dann entsteht der Code, der diesen Test erfüllt. Das klingt nach Mehraufwand, und am Anfang ist es das auch. Ob sich der Aufwand lohnt, hängt stark von der Art des Projekts ab, und die Studienlage ist weniger eindeutig, als es Befürworter oft darstellen.
Was Test-Driven Development ist und was nicht
TDD wurde in den späten 1990er-Jahren im Umfeld von Extreme Programming bekannt und vor allem von Kent Beck beschrieben, dessen Buch „Test-Driven Development: By Example“ bis heute als Standardwerk gilt. Der Kern ist ein kurzer, sich ständig wiederholender Zyklus aus drei Schritten:
- Rot: Einen kleinen Test schreiben, der ein noch fehlendes Verhalten beschreibt. Er schlägt fehl, weil der Code dafür noch nicht existiert.
- Grün: Gerade so viel Code schreiben, dass dieser Test besteht. Eleganz ist in diesem Schritt nebensächlich.
- Refactor: Den Code aufräumen, also Struktur verbessern, ohne das Verhalten zu ändern. Die Tests sichern ab, dass dabei nichts kaputtgeht.
Ein Durchlauf dauert typischerweise nur wenige Minuten. Entscheidend ist der kleine Schritt: Statt eine ganze Funktion zu entwerfen, wächst sie Test für Test.
Wichtig ist die Abgrenzung zu Unit-Tests allgemein. Unit-Tests, also automatische Tests für einzelne Funktionen oder Klassen, kann man auch nachträglich schreiben. Bei TDD ist der Test dagegen ein Entwurfswerkzeug: Wer zuerst den Test formuliert, muss sich vorher überlegen, wie der Code aufgerufen wird, welche Eingaben er bekommt und was als Ergebnis gilt. Das Ergebnis sind oft kleinere Funktionen mit klareren Schnittstellen, weil sich schlecht testbarer Code beim Schreiben des Tests sofort bemerkbar macht.
TDD an einem Beispiel: die Versandkostenregel
Angenommen, die Versandkosten des Webshops aus dem Einstieg sollen neu entwickelt werden. Mit dem Testframework pytest beginnt der erste Zyklus mit einem Test für den einfachsten Fall:
# test_versand.py
from versand import versandkosten
def test_inland_unter_grenze_kostet_versand():
assert versandkosten(warenwert=30.0, land="DE") == 4.90
Der Test schlägt fehl, weil es das Modul versand noch nicht gibt. Das ist der rote Schritt. Für den grünen Schritt genügt zunächst eine sehr schlichte Lösung:
# versand.py
def versandkosten(warenwert: float, land: str) -> float:
return 4.90
Das wirkt fast albern, hat aber einen Zweck: Der Test ist jetzt nachweislich in der Lage, rot und grün zu unterscheiden. Die nächsten Tests erzwingen die eigentliche Logik:
def test_inland_ab_grenze_versandkostenfrei():
assert versandkosten(warenwert=50.0, land="DE") == 0.0
def test_ausland_kostet_immer_versand():
assert versandkosten(warenwert=80.0, land="AT") == 12.90
Nach diesen beiden Tests entsteht eine vollständige Funktion. Im Refactor-Schritt werden die festen Zahlen zu benannten Konstanten:
# versand.py
GRENZE_VERSANDKOSTENFREI = 50.0
VERSAND_INLAND = 4.90
VERSAND_AUSLAND = 12.90
def versandkosten(warenwert: float, land: str) -> float:
if land != "DE":
return VERSAND_AUSLAND
if warenwert >= GRENZE_VERSANDKOSTENFREI:
return 0.0
return VERSAND_INLAND
Ein Aufruf von pytest führt alle drei Tests aus. Der Gewinn zeigt sich bei der nächsten Änderung: Wer die Grenze verschiebt oder die Auslandsregel anfasst, merkt sofort, wenn ein festgelegtes Verhalten bricht. Die Ausnahme fürs Ausland ist nicht mehr implizites Wissen, sondern steht als lesbarer Test im Repository. Für echte Geldbeträge würde man im Produktivcode übrigens Decimal statt Gleitkommazahlen verwenden, um Rundungsfehler zu vermeiden. Hier bleibt das Beispiel bewusst einfach.
Wie dieselbe Arbeitsweise in einem Webframework mit Datenbank, Views und Formularen aussieht, zeigt unser Praxisbeitrag zu Django Testing und TDD.
Was die Forschung über TDD sagt
Häufig zitiert wird eine Fallstudie von Microsoft und IBM, die 2008 erschien. Sie untersuchte vier Industrieteams und berichtete, dass die Fehlerdichte vor der Auslieferung bei den TDD-Teams um 40 bis 90 Prozent niedriger lag als bei vergleichbaren Projekten. Gleichzeitig dauerte die anfängliche Entwicklung nach Einschätzung der Teams 15 bis 35 Prozent länger.
Diese Zahlen sind eindrucksvoll, man sollte sie aber einordnen. Es handelte sich um wenige Teams, die Vergleichsprojekte waren nicht identisch, und motivierte Teams, die eine neue Methode ausprobieren, arbeiten oft ohnehin sorgfältiger. Spätere Übersichtsarbeiten, die viele Einzelstudien zusammenfassen, kommen zu einem vorsichtigeren Bild: eher kleine bis mittlere Verbesserungen bei der externen Qualität, kein eindeutiger Effekt auf die Produktivität, und große Unterschiede zwischen Studien mit Studierenden und solchen mit erfahrenen Profis. Einige Experimente deuten darauf hin, dass ein Teil des Nutzens weniger aus dem „Test zuerst“ stammt als aus dem Arbeiten in sehr kleinen, überprüften Schritten.
Unsere Lesart: TDD ist keine Garantie für weniger Fehler, aber eine wirksame Disziplin, um Tests tatsächlich zu schreiben, statt sie auf später zu verschieben. Wer nachträglich ebenso gründlich testet, erreicht oft ähnliche Ergebnisse. In der Praxis passiert das jedoch selten, weil Tests unter Zeitdruck als Erstes wegfallen.
Wo TDD seine Stärken ausspielt
Besonders gut passt TDD zu Code, dessen Verhalten sich präzise beschreiben lässt:
- Geschäftslogik mit Regeln und Ausnahmen: Preisberechnung, Rabatte, Fristen, Berechtigungen. Jede Regel wird zu einem Test, der zugleich als Dokumentation dient.
- Langlebige Systeme: Wer Code über Jahre pflegt, profitiert von einer Testsuite, die Änderungen absichert. Refactoring wird erst damit risikoarm.
- Fehlerbehebung: Auch Teams, die sonst nicht testgetrieben arbeiten, nutzen das Prinzip bei Bugs. Zuerst ein Test, der den Fehler reproduziert, dann die Korrektur. So kehrt derselbe Fehler nicht unbemerkt zurück.
- Bibliotheken und Schnittstellen: Der Test zwingt dazu, die Schnittstelle aus Sicht der Nutzenden zu entwerfen.
Wo TDD an Grenzen stößt
Weniger geeignet ist TDD, wo das gewünschte Verhalten noch unklar ist oder sich schwer automatisch prüfen lässt:
- Prototypen und Experimente: Wer erst herausfinden will, ob eine Idee trägt, schreibt den Code oft ohnehin neu. Ein üblicher Weg ist ein bewusst wegwerfbarer Prototyp, ein sogenannter Spike, und danach eine testgetriebene Umsetzung.
- Oberflächen und Layout: Ob eine Seite gut aussieht, beantwortet kein Unit-Test. Hier helfen eher End-to-End-Tests und manuelle Prüfung.
- Starke Abhängigkeiten von Fremdsystemen: Wenn fast jede Funktion eine Datenbank, eine externe Schnittstelle oder Dateien berührt, entstehen schnell Tests voller Attrappen (Mocks), die mehr den Aufbau als das Verhalten prüfen. Solche Tests brechen bei jedem Umbau und schützen wenig.
Auch in der Entwicklergemeinde ist TDD nicht unumstritten. 2014 diskutierten Kent Beck, Martin Fowler und Ruby-on-Rails-Erfinder David Heinemeier Hansson öffentlich unter dem Titel „Is TDD dead?“ über die Methode. Hansson warnte, strikt dogmatisches TDD könne zu verkrampftem Design führen, Beck und Fowler sahen die Ursache eher in einzelnen Designentscheidungen. Einig waren sich alle drei, dass Code mit eigenen automatischen Tests wertvoll ist.
Warum TDD mit KI-Assistenten wichtiger wird
Mit Code-Assistenten auf Basis großer Sprachmodelle hat TDD eine neue Rolle bekommen. Wer ein KI-Werkzeug Code schreiben lässt, braucht eine Möglichkeit, dessen Ergebnis zuverlässig zu prüfen. Tests, die vorher von Menschen formuliert wurden, sind dafür eine naheliegende Spezifikation: Sie legen fest, was als richtig gilt, und der generierte Code muss sich daran messen lassen.
Umgekehrt ist Vorsicht geboten, wenn die KI sowohl Code als auch Tests erzeugt. Dann prüfen die Tests häufig nur, was der Code ohnehin tut, und übernehmen dessen Fehler. Für Teams, die KI-Assistenten einsetzen, ist das ein gutes Argument, zumindest die Tests für wichtige Geschäftsregeln weiterhin selbst zu schreiben oder sorgfältig zu prüfen.
TDD im Team einführen
Eine Methode, die Gewohnheiten umkehrt, lässt sich nicht per Anweisung einführen. Bewährt hat sich ein schrittweises Vorgehen:
- Klein anfangen: Ein überschaubares Modul mit klarer Logik eignet sich besser als der Kern eines Altsystems.
- Üben, bevor es ernst wird: Code-Katas, also kleine wiederholbare Programmieraufgaben wie das Bowling-Spiel oder römische Zahlen, helfen, den Rhythmus zu verinnerlichen.
- Zu zweit arbeiten: Beim Pair Programming schreibt eine Person den Test, die andere die Implementierung. Das macht die Methode sichtbar und lehrt viel.
- Tests automatisch ausführen: Ohne Continuous Integration, also das automatische Bauen und Testen bei jeder Änderung, verliert eine Testsuite schnell an Wert.
- Erfolg sinnvoll messen: Aussagekräftiger als die reine Testabdeckung sind die Zahl der Fehler nach Releases, der Anteil zurückgerollter Deployments und die Zeit von der Änderung bis zur Auslieferung.
Eine Warnung zur Testabdeckung: Wird ein Prozentwert zum Ziel, entstehen schnell Tests, die Zeilen ausführen, ohne etwas Sinnvolles zu prüfen. Die Abdeckung zeigt, welcher Code ungetestet ist, aber nicht, wie gut der Rest getestet ist. Wie sich Tests in eine Build-Pipeline einbinden lassen, beschreibt die Infothek unter TDD, Qualitätssicherung und CI/CD mit Python.
Was das für Ihr Team bedeutet
TDD ist kein Allheilmittel und keine Glaubensfrage. Für Teams, die langlebige Software mit viel Geschäftslogik pflegen, lohnt sich der Einstieg fast immer, zumindest für die Kernregeln und für jede Fehlerbehebung. Der anfängliche Mehraufwand ist real und sollte offen eingeplant werden, statt ihn kleinzureden.
Überschätzt werden dagegen die großen Prozentzahlen aus einzelnen Studien. Realistischer ist die Erwartung, dass TDD Fehler früher sichtbar macht, Refactoring absichert und Anforderungen in überprüfbare Form bringt. Wer dazu bereit ist, die Methode pragmatisch statt dogmatisch einzusetzen, erhält damit ein solides Fundament, auf dem auch die Arbeit mit KI-Assistenten sicherer wird.
Häufige Fragen zu Test-Driven Development
Verlangsamt TDD die Entwicklung?
Am Anfang ja. Die oft zitierte Fallstudie nennt 15 bis 35 Prozent mehr Zeit für die erste Entwicklung. Dem stehen weniger Fehler in späteren Phasen und eine leichtere Wartung gegenüber. Ob sich das ausgleicht, hängt davon ab, wie lange und wie intensiv der Code gepflegt wird.
Muss wirklich jede Zeile Code testgetrieben entstehen?
Nein. Viele erfahrene Teams nutzen TDD gezielt für Geschäftslogik und Fehlerbehebungen und testen Oberflächen oder einfachen Verbindungscode auf anderem Weg. Wichtiger als die reine Lehre ist, dass kritisches Verhalten durch automatische Tests abgesichert ist.
Welche Werkzeuge braucht man für TDD?
Ein Testframework für die jeweilige Sprache genügt, etwa pytest für Python, JUnit für Java oder Vitest und Jest für JavaScript und TypeScript. Hilfreich sind eine Entwicklungsumgebung, die Tests mit einem Tastendruck startet, und eine CI-Pipeline, die alle Tests bei jeder Änderung ausführt.
Wie überzeugt man ein skeptisches Team?
Mit einem gemeinsamen Versuch statt mit Zahlen. Ein Pilotmodul, ein paar Wochen Erfahrung und eine offene Auswertung, was besser und was mühsamer geworden ist, wirken überzeugender als jede Studie.
Wer TDD und automatisierte Tests in bestehende Abläufe einbetten möchte, findet auf unserer Themenseite zu CI/CD-Pipelines Angebote für Beratung, Coaching und Seminare.
Kategorien