Testgetriebene Entwicklung erklärt: warum der Test zuerst kommt
Kurz gesagt
Niveau: Einstieg
Ein automatisierter Test ist ein kleines Stück Code, das eine Antwort prüft: Lage vorbereiten, ausführen, Ergebnis prüfen.
- Testgetriebene Entwicklung (TDD) schreibt diesen Test zuerst, sieht ihn aus dem richtigen Grund scheitern, schreibt gerade genug Code zum Bestehen und räumt dann auf, während alles grün bleibt.
- Testliste, Babyschritte, Vortäuschen und Triangulieren halten die Schritte klein und ehrlich. Testnamen, die Verhalten beschreiben, machen die Testdatei zur Spezifikation, die auch das Geschäft lesen kann.
- Forschung: 40 bis 90 % weniger Fehler vor dem Release bei vier Industrieteams, ein kleiner positiver Effekt auf die Qualität über 27 Studien, und der meiste Nutzen steckt in kleinen, gleichmäßigen Schritten.
- Weißt du noch nicht, was du bauen sollst, mach einen Spike, lern daraus und wirf ihn weg. Trägt der Code über Jahre Geld oder Regeln, schreib zuerst den Test.
Fragst du, woher jemand weiß, dass der eigene Code funktioniert, hörst du meistens "Ich hab's ausprobiert". Das hält für den einen Tag und sagt nichts über den nächsten Monat. Testgetriebene Entwicklung ist eine andere Antwort: zuerst die Prüfung schreiben, sie scheitern sehen, dann den Code schreiben. Hier von null an erklärt, Runde für Runde am Rabattcode eines Onlineshops für Tee gebaut, mit dem, was es kostet, und dem, was die Forschung sagt.
Die Frage hinter diesem Artikel
Frag eine Entwicklerin, woher sie weiß, dass ihr Code funktioniert, und du hörst meistens: "Ich hab's ausprobiert." Sie hat sich durch den Shop geklickt, der Rabatt wurde abgezogen, die Bestellung ging durch. Für diesen Tag ist das eine ehrliche Antwort. Über den nächsten Monat sagt sie nichts, wenn drei neue Features und ein Update später niemand mehr genau diesen Weg durchklickt.
Testgetriebene Entwicklung, auf Englisch Test Driven Development (TDD), ist eine andere Antwort. Du schreibst zuerst ein kleines Stück Code, das das gewünschte Verhalten prüft, siehst zu, wie es scheitert, und erst dann schreibst du den Code, der es bestehen lässt. Beim ersten Hören klingt das verkehrt herum. Am Ende dieses Artikels soll es wie die naheliegende Reihenfolge klingen, und du sollst wissen, was es kostet, was die Forschung dazu sagt und wann du es getrost weglassen darfst.
Ich nutze durchgehend ein erfundenes Unternehmen. Das Teehaus am Grieskai ist ein Onlineshop für Tee in Graz (teehausgrieskai.example). Es verkauft losen Tee und Tee Abos, nimmt Kartenzahlungen über einen Zahlungsdienstleister an, hat Rabattcodes, einen Lagerbestand und verschickt Bestellmails. Entwickelt wird der Shop von Jana. Shop und Jana sind erfunden, der Code ist echt und läuft.
Was ein automatisierter Test ist
Ein automatisierter Test ist ein kleines Stück Code, das einen Teil deiner echten Software ausführt und eine Antwort prüft. Stimmt die Antwort, ist der Test grün. Stimmt sie nicht, schlägt er fehl und sagt dir, was er stattdessen bekommen hat. Du kannst Hunderte davon in wenigen Sekunden laufen lassen, so oft du willst, und sie werden nie müde und überspringen keinen Schritt.
Fast jeder gute Test hat dieselben drei Teile. Bill Wake hat das Muster 2001 Arrange, Act, Assert getauft1. Auf Deutsch:
- Arrange (vorbereiten): die Lage herstellen. Ein Warenkorb mit bestimmten Artikeln, eine Kundin, ein Datum.
- Act (ausführen): genau das eine tun, das du testest. Die Versandkosten abfragen, einen Code einlösen.
- Assert (prüfen): das Ergebnis mit der erwarteten Antwort vergleichen.
In Ruby on Rails, dem Framework, mit dem ich baue, liegen Tests im Ordner test und laufen mit einem einzigen Befehl, bin/rails test. Rails nutzt dafür standardmäßig die Testbibliothek Minitest2.
Beispiel: die Gratisversand Regel des Teehauses als Test
Das Teehaus am Grieskai versendet ab € 25 Bestellwert kostenlos. So sieht diese Regel als Test aus:
require "test_helper"
class DeliveryTest < ActiveSupport::TestCase
test "Versand ist ab 25 Euro kostenlos" do
# Vorbereiten: ein Warenkorb über genau 25 Euro, in Cent gezählt
basket_cents = 2500
# Ausführen: den Shop fragen, was der Versand kostet
fee = Delivery.fee_for(basket_cents)
# Prüfen: kostenlos heißt null Euro Gebühr
assert_equal 0, fee
end
end
Zeile für Zeile:
require "test_helper"lädt die Testumgebung, die Rails jedem Projekt mitgibt.class DeliveryTest < ActiveSupport::TestCaseist eine Gruppe von Tests. Der Name sagt, worum es geht.test "Versand ist ab 25 Euro kostenlos" dobeginnt einen Test. Der Text in Anführungszeichen ist sein Name, formuliert als Satz über ein Verhalten.basket_cents = 2500ist das Vorbereiten. Geld wird in ganzen Cent gezählt, weil Computer manche Kommazahlen nur ungenau speichern und Cents dann gern verschwinden.fee = Delivery.fee_for(basket_cents)ist das Ausführen: Hier läuft echter Shopcode.assert_equal 0, feeist das Prüfen. Lies es als "Ich erwarte 0, und das hier habe ich bekommen". Istfeeirgendetwas anderes als 0, schlägt der Test fehl und zeigt beide Zahlen.
Mehr ist ein Test nicht. Eine aufgeschriebene Erwartung, die eine Maschine für dich prüft.
Warum der Test zuerst kommt
Wer überhaupt Tests schreibt, schreibt sie meistens hinterher. Erst das Feature, dann ein paar Tests drumherum. TDD dreht die Reihenfolge um, aus drei Gründen.
Du beweist, dass der Test scheitern kann. Ein Test, den du nur je grün gesehen hast, prüft vielleicht gar nichts. Ihn zuerst scheitern zu sehen, und zwar aus dem Grund, den du erwartest, ist der einzige Beweis, dass er das Verhalten wirklich bewacht.
Du entscheidest das Verhalten, bevor du es baust. Die Erwartung aufzuschreiben, erzwingt die Fragen, die im Meeting niemand gestellt hat. Was passiert bei genau € 20? Was, wenn der Code gestern abgelaufen ist? Solche Fragen sind viel günstiger zu beantworten, solange es den Code noch nicht gibt.
Du entwirfst den Code aus Sicht dessen, der ihn benutzt. Der Test ist der erste Code, der deinen neuen Code aufruft. Ist er umständlich zu schreiben, ist der Entwurf umständlich, und du merkst es in dem Moment, in dem eine Änderung noch nichts kostet.
Martin Fowler fasst die ganze Praxis in drei Schritten zusammen: einen Test für das nächste Stück Funktionalität schreiben, den Code schreiben, bis der Test besteht, dann neuen und alten Code aufräumen, bis er gut strukturiert ist3. Kent Beck, der die Methode 2002 in seinem Buch Test Driven Development: By Example beschrieben hat, ist der, von dem die meisten sie lernen4.
Beispiel: der Test, der nie scheitern konnte
Angenommen, Jana hätte den Rabattcode des Teehauses zuerst gebaut und danach diesen Test ergänzt:
test "zieht den Rabatt ab" do
code = DiscountCode.new(percent: 10, minimum_cents: 2000,
expires_on: Date.new(2026, 12, 31))
assert code.discount_for(subtotal_cents: 3000, on: Date.new(2026, 11, 20))
end
Er ist grün. Er sieht gewissenhaft aus. Er ist wertlos. Ein schlichtes assert prüft nur, ob die Antwort als "wahr" gilt, und in Ruby gilt jede Zahl als wahr, auch die 0. Nur nil und false lassen ihn scheitern. Der Test ist also grün, egal ob der Rabatt € 3, € 300 oder gar nichts beträgt.
Hätte Jana ihn zuerst geschrieben, hätte sie ihn laufen lassen, bevor es den Rabattcode gab, ihn scheitern sehen und sich dann die richtige Frage gestellt: Woran scheitert er, und was genau soll grün werden? Diese Frage führt direkt zu assert_equal 300, ..., einem Test, der die echte Zahl festnagelt. Den Test zuerst zu schreiben, ist kein Ritual. Es ist der schnellste Weg herauszufinden, ob dein Test überhaupt etwas sieht.
Rot, grün, refaktorieren: die Schleife
TDD läuft in einer kurzen Schleife mit drei Farben, benannt nach dem, was die meisten Testwerkzeuge anzeigen3:
- Rot: einen kleinen Test schreiben und ausführen. Er scheitert, weil es das Verhalten noch nicht gibt.
- Grün: den wenigsten Code schreiben, der ihn bestehen lässt. Nicht schön. Nur genug.
- Refaktorieren: Jetzt, wo alles grün ist, aufräumen. Umbenennen, Doppeltes entfernen, vereinfachen. Nach jeder Änderung die Tests erneut laufen lassen, damit sie grün bleiben.
Dann nimmst du das nächste Verhalten und drehst die nächste Runde. Eine Runde dauert Minuten, keine Stunden. Und die Schleife hat eine Entscheidung, die Neulinge gern überspringen und Erfahrene nie: Wenn der Test rot wird, scheitert er aus dem richtigen Grund?
Beispiel: Janas erste Runde
Das Teehaus will einen Rabattcode, WELCOME10, der 10 % auf den Tee im Warenkorb gibt. Jana schreibt den ersten Test in test/models/discount_code_test.rb:
require "test_helper"
class DiscountCodeTest < ActiveSupport::TestCase
test "gibt 10 Prozent auf einen Warenkorb über 30 Euro" do
code = DiscountCode.new(percent: 10, minimum_cents: 2000,
expires_on: Date.new(2026, 12, 31))
assert_equal 300, code.discount_for(subtotal_cents: 3000,
on: Date.new(2026, 11, 20))
end
end
10 % von € 30 sind € 3, also 300 Cent. Sie startet bin/rails test test/models/discount_code_test.rb und bekommt Rot:
Error:
DiscountCodeTest#test_gibt_10_Prozent_auf_einen_Warenkorb_über_30_Euro:
NameError: uninitialized constant DiscountCodeTest::DiscountCode
Rot, aber aus dem falschen Grund. Der Test hat den Rabatt gar nicht geprüft, er ist umgefallen, weil es die Klasse nicht gibt. Das ist der Zweig "nein" der Entscheidung. Jana legt die kleinstmögliche Klasse in app/models/discount_code.rb an:
class DiscountCode
def initialize(percent:, minimum_cents:, expires_on:)
end
def discount_for(subtotal_cents:, on:)
end
end
Sie startet den Test noch einmal:
Failure:
DiscountCodeTest#test_gibt_10_Prozent_auf_einen_Warenkorb_über_30_Euro:
Expected: 300
Actual: nil
Jetzt scheitert er aus dem richtigen Grund: Er wollte 300 und hat nichts bekommen. Dieser Test kann sehen. Weiter zu Grün, und das ist der nächste Gedanke.
Mit einer Testliste anfangen, dann in Babyschritten gehen
Vor dem ersten Test schreibst du eine schlichte Liste der Verhaltensweisen, die du abdecken willst. Kent Beck nennt sie die Testliste und stellt sie an den Anfang dessen, was er "Canon TDD" nennt: Liste schreiben, genau einen Punkt in einen echten Test verwandeln, ihn grün machen, bei Bedarf refaktorieren, wiederholen, bis die Liste leer ist5. Er warnt auch vor einem typischen Fehler: alle Punkte der Liste vorab in Tests zu verwandeln und dann zu versuchen, sie gemeinsam grün zu bekommen5. Einer nach dem anderen, darum geht es.
Robert C. Martin hat dieselbe Disziplin in drei Regeln gegossen6. Sinngemäß lauten sie:
- Du darfst keinen Produktivcode schreiben, außer um einen scheiternden Test grün zu machen.
- Du darfst nicht mehr von einem Test schreiben, als nötig ist, damit er scheitert, und nicht kompilieren zählt als scheitern.
- Du darfst nicht mehr Produktivcode schreiben, als nötig ist, damit der eine scheiternde Test besteht.
Das klingt streng, und so ist es gemeint. Die Wirkung: Du bist nie mehr als ein paar Minuten von Code entfernt, der funktioniert. Geht etwas schief, machst du die letzten Minuten rückgängig, nicht die letzten Tage. Diese kleinen Züge heißen Babyschritte.
Beispiel: Janas Testliste für WELCOME10
Jana setzt sich zehn Minuten mit der Inhaberin des Teehauses zusammen und schreibt diese Liste als Kommentar oben in die Testdatei:
# Testliste für Rabattcodes
# 1. 10 Prozent auf 30 Euro ergeben 3 Euro
# 2. 10 Prozent auf 45 Euro ergeben 4,50 Euro
# 3. unter dem Mindestbestellwert von 20 Euro gibt es keinen Rabatt
# 4. bei genau 20 Euro gilt der Rabatt
# 5. nach dem Ablaufdatum gibt es keinen Rabatt
# 6. halbe Cent werden abgerundet, nie aufgerundet
Punkt 6 ist aus dem Gespräch entstanden. Die Inhaberin will nicht, dass ein Code je mehr als 10 % verschenkt, also gehen halbe Cent zugunsten des Shops. Ohne die Liste hätte diese Entscheidung einfach Rubys Voreinstellung getroffen, und niemand hätte es gemerkt. Die Liste ist Verhalten, in einfachen Worten aufgeschrieben, noch vor jedem Entwurf. Jana hakt pro Runde eine Zeile ab.
Drei Wege zu Grün: vortäuschen, triangulieren, offensichtliche Umsetzung
Wenn ein Test rot ist, wie viel Code schreibst du dann? Becks Buch nennt drei Strategien, und zu wissen, wann welche passt, ist schon ein Großteil des Handwerks4:
- Fake it (vortäuschen): genau die Antwort zurückgeben, die der Test erwartet, eine Konstante. Das fühlt sich nach Schummeln an. Es beweist, dass Test und Verdrahtung funktionieren, und der nächste Test erzwingt die echte Logik.
- Triangulate (triangulieren): ein zweites Beispiel mit einer anderen Antwort ergänzen, sodass die Vortäuschung nicht mehr reicht. Die allgemeine Regel entsteht erst, wenn zwei Beispiele sie verlangen.
- Obvious Implementation (offensichtliche Umsetzung): Wenn du den richtigen Code siehst und er klein ist, schreib ihn einfach. Liegst du daneben, gehst du zurück zu kleineren Schritten.
Beispiel: die Punkte 1 bis 3 der Testliste
Punkt 1, vortäuschen. Der Test will 300, also gibt Jana 300 zurück:
def discount_for(subtotal_cents:, on:)
300
end
Grün. Offensichtlich nicht fertig, und das passt eh: Auf der Liste stehen noch fünf Zeilen.
Punkt 2, triangulieren. Sie ergänzt einen zweiten Test:
test "gibt 10 Prozent auf einen Warenkorb über 45 Euro" do
assert_equal 450, welcome10.discount_for(subtotal_cents: 4500,
on: Date.new(2026, 11, 20))
end
Rot: erwartet 450, bekommen 300. Die Vortäuschung kann nicht beide Tests erfüllen, also muss die echte Regel her:
class DiscountCode
def initialize(percent:, minimum_cents:, expires_on:)
@percent = percent
@minimum_cents = minimum_cents
@expires_on = expires_on
end
def discount_for(subtotal_cents:, on:)
(subtotal_cents * @percent).fdiv(100).round
end
end
Der Konstruktor merkt sich jetzt die drei Einstellungen. Die Methode multipliziert die Zwischensumme mit dem Prozentsatz, teilt durch 100 und rundet auf ganze Cent. Beide Tests sind grün.
Der neue Test nutzt welcome10, eine kleine Hilfsmethode unten in der Testklasse, damit Jana nicht in jedem Test dieselbe Zeile wiederholt:
private
def welcome10
DiscountCode.new(percent: 10, minimum_cents: 2000,
expires_on: Date.new(2026, 12, 31))
end
Sie baut den Code WELCOME10 mit seinen drei Einstellungen: 10 %, ein Mindestbestellwert von 2.000 Cent und das Ablaufdatum 31. Dezember 2026. Auch der erste Test nutzt sie ab jetzt. Die Hilfsmethode einzubauen ist ein Refactoring des Testcodes, gemacht, während alles grün ist, und danach lässt Jana beide Tests sicherheitshalber noch einmal laufen.
Punkt 3, offensichtliche Umsetzung. Der Test für den Mindestbestellwert:
test "gibt unter dem Mindestbestellwert von 20 Euro keinen Rabatt" do
assert_equal 0, welcome10.discount_for(subtotal_cents: 1500,
on: Date.new(2026, 11, 20))
end
Rot: erwartet 0, bekommen 150. Die Lösung ist eine Zeile, die Jana klar vor sich sieht, also schreibt sie sie direkt:
def discount_for(subtotal_cents:, on:)
return 0 if subtotal_cents < @minimum_cents
(subtotal_cents * @percent).fdiv(100).round
end
return 0 if ... verlässt die Methode vorzeitig ohne Rabatt, wenn der Warenkorb zu klein ist. Drei Tests, alle grün.
Auch ein Test, der sofort grün ist, muss beweisen, dass er scheitern kann
Manchmal schreibst du den nächsten Test, und er ist auf Anhieb grün. Das ist nicht automatisch eine gute Nachricht. Entweder kann der Code den Fall schon, oder der Test prüft nicht das, was du denkst. Unterscheiden kannst du das nur, indem du den Code kurz absichtlich kaputt machst und zusiehst, wie der Test rot wird.
Beispiel: die Grenze bei 20 Euro
Punkt 4 sagt, dass der Rabatt bei genau € 20 gilt. Jana schreibt:
test "gilt bei genau 20 Euro Mindestbestellwert" do
assert_equal 200, welcome10.discount_for(subtotal_cents: 2000,
on: Date.new(2026, 11, 20))
end
Er ist sofort grün, weil subtotal_cents < @minimum_cents bei Gleichheit falsch ist. Um zu beweisen, dass der Test wach ist, ändert sie im Code < in <=, startet die Tests und sieht genau diesen einen scheitern: erwartet 200, bekommen 0. Sie macht die Änderung rückgängig, und alles ist wieder grün.
Werte wie € 20 heißen Grenzwerte: der genaue Punkt, an dem sich das Verhalten ändert. Fehler lieben sie, weil "unter 20" und "bis 20" im Meeting fast gleich klingen und sich an der Kassa verschieden verhalten. Dieser Test bewacht die Linie jetzt, solange es den Shop gibt.
Refaktorieren nur, wenn alles grün ist
Refaktorieren heißt, die Struktur von Code zu ändern, ohne zu ändern, was er tut. Es ist der dritte Schritt der Schleife, und Fowler nennt das Weglassen dieses Schritts die häufigste Art, TDD falsch zu machen3. Zwei Regeln halten es sicher. Refaktoriere nur, wenn alle Tests grün sind, damit du weißt, wo du angefangen hast. Und füge beim Refaktorieren nie neues Verhalten hinzu: Neues Verhalten ist ein neuer roter Test. Beck führt das Vermischen von Refaktorieren und Grünmachen ausdrücklich als eigenen Fehler auf5.
Beispiel: das Ablaufdatum, dann aufräumen
Punkt 5: kein Rabatt nach dem Ablaufdatum.
test "gibt nach dem Ablaufdatum keinen Rabatt" do
assert_equal 0, welcome10.discount_for(subtotal_cents: 3000,
on: Date.new(2027, 1, 1))
end
Rot: erwartet 0, bekommen 300. Grün mit einer weiteren Wächterzeile:
def discount_for(subtotal_cents:, on:)
return 0 if subtotal_cents < @minimum_cents
return 0 if on > @expires_on
(subtotal_cents * @percent).fdiv(100).round
end
Jetzt ist alles grün, also refaktoriert Jana. Die beiden Wächterzeilen sind eigentlich eine Frage, "gilt dieser Code heute für diesen Warenkorb?", also gibt sie der Frage einen Namen:
def discount_for(subtotal_cents:, on:)
return 0 unless applies_to?(subtotal_cents, on)
(subtotal_cents * @percent).fdiv(100).round
end
private
def applies_to?(subtotal_cents, on)
subtotal_cents >= @minimum_cents && on <= @expires_on
end
unless heißt "wenn nicht". private versteckt die Hilfsmethode vor dem Rest des Shops, weil niemand von außen sie aufrufen muss. Nach der Änderung lässt sie alle fünf Tests laufen. Immer noch grün, das Verhalten ist also gleich, und der Code liest sich jetzt wie die Regel.
Tests nach Verhalten benennen, nicht nach Methoden
Ein Testname wie test_discount_for sagt dir, welche Methode beteiligt ist, und nichts darüber, was passieren soll. Ein Name wie "gibt nach dem Ablaufdatum keinen Rabatt" ist ein Satz der Spezifikation. Scheitert er in einem Jahr, sagt schon die Fehlermeldung der Person, die gerade Dienst hat, welches Versprechen gerade gebrochen wurde. Lies die Namen einer Testdatei von oben nach unten, und du solltest die Regeln des Features in einfachen Worten haben, ohne den Code zu öffnen.
Beispiel: Punkt 6, und die fertige Testdatei
Der letzte Punkt ist die geschäftliche Entscheidung über halbe Cent. Ein Warenkorb über € 24,95 ergibt bei 10 % genau 249,5 Cent. Die Inhaberin will das auf 249 abgerundet haben.
test "rundet halbe Cent zugunsten des Shops ab" do
assert_equal 249, welcome10.discount_for(subtotal_cents: 2495,
on: Date.new(2026, 11, 20))
end
Rot: erwartet 249, bekommen 250, weil Rubys round eine Hälfte aufrundet. Jana ersetzt die Rechnung durch eine Ganzzahldivision, die in Ruby bei positiven Zahlen immer abrundet:
subtotal_cents * @percent / 100
Grün, und alle früheren Tests sind es auch. Hier die fertige Klasse:
class DiscountCode
def initialize(percent:, minimum_cents:, expires_on:)
@percent = percent
@minimum_cents = minimum_cents
@expires_on = expires_on
end
def discount_for(subtotal_cents:, on:)
return 0 unless applies_to?(subtotal_cents, on)
subtotal_cents * @percent / 100
end
private
def applies_to?(subtotal_cents, on)
subtotal_cents >= @minimum_cents && on <= @expires_on
end
end
Und hier die sechs Testnamen, der Reihe nach, so wie der Testlauf sie auflistet:
gibt 10 Prozent auf einen Warenkorb über 30 Euro
gibt 10 Prozent auf einen Warenkorb über 45 Euro
gibt unter dem Mindestbestellwert von 20 Euro keinen Rabatt
gilt bei genau 20 Euro Mindestbestellwert
gibt nach dem Ablaufdatum keinen Rabatt
rundet halbe Cent zugunsten des Shops ab
Diese Liste ist die Rabattregel des Teehauses am Grieskai. Die Inhaberin kann sie lesen, und die Maschine prüft jede Zeile in deutlich unter einer Sekunde, jedes Mal, wenn irgendwer irgendetwas ändert. Sechs Runden der Schleife, vielleicht eine halbe Stunde Arbeit, und jede Entscheidung aus dem Gespräch steht jetzt dort, wo sie nicht mehr wegdriften kann.
Was TDD nicht ist
Ein paar Missverständnisse kommen so oft vor, dass sie einen eigenen Abschnitt verdienen.
Es ist keine Jagd auf 100 % Abdeckung. Werkzeuge für die Testabdeckung (Coverage) zeigen, welche Codezeilen während der Tests gelaufen sind. Fowler nennt Coverage ein nützliches Werkzeug, um ungetestete Teile einer Codebasis zu finden, und als Zahl für die Güte der Tests wenig brauchbar. Er warnt außerdem, dass ein Abdeckungsziel dazu einlädt, es auszutricksen7. TDD bringt hohe Abdeckung oft als Nebenwirkung mit. Das Ziel ist sie nicht.
Es ist nicht Tests hinterher schreiben. Tests nach dem Code sind trotzdem wertvoll, und sie einem alten System nachträglich zu geben, ist oft genau richtig. Aber sie können dir den roten Schritt nicht zeigen, und sie testen eher, was der Code zufällig tut, als was er tun soll.
Es ist nicht der einzige Test, den du brauchst. TDD in dieser Form liefert kleine, schnelle Tests einzelner Regeln. Ein Shop braucht auch Tests, die sich im Browser durch den echten Checkout klicken. Darum geht es im Kapitel über Unit, Integrations und End to End Tests.
Es ist kein Verbot, etwas auszuprobieren. Wenn du noch nicht weißt, was du bauen sollst, erkundest du zuerst. Mehr dazu im Abschnitt über Spikes.
Beispiel: 100 % Abdeckung, und der Fehler ist zurück
Stell dir vor, Jana löscht den Rundungstest und stellt die Rechnung zurück auf (subtotal_cents * @percent).fdiv(100).round. Jede Zeile von DiscountCode läuft immer noch während der fünf übrigen Tests. Der Abdeckungsbericht zeigt weiter 100 %. Und der Shop verschenkt wieder bei jedem krummen Warenkorb einen halben Cent, gegen die ausdrückliche Entscheidung der Inhaberin. Die Abdeckung hat gemessen, welche Zeilen gelaufen sind. Nur der Test "rundet halbe Cent zugunsten des Shops ab" hat gemessen, ob die Regel eingehalten wird.
Was es kostet, und was die Forschung sagt
TDD ist nicht gratis, und wer das behauptet, hat es noch nie unter Termindruck gemacht. Das ehrliche Bild aus der Forschung: positiv bei der Qualität, gemischt beim Tempo, und differenzierter, als beide Lager im Netz gern zugeben.
Die meistzitierte Studie kommt von Microsoft und IBM. Nachiappan Nagappan und Kollegen haben vier Teams aus der Industrie begleitet, die TDD eingeführt hatten. Ihre Fehlerdichte vor dem Release, also gefundene Fehler pro tausend Codezeilen, sank um 40 bis 90 % im Vergleich zu ähnlichen Projekten ohne TDD. Gleichzeitig empfanden die Teams die anfängliche Entwicklungszeit als 15 bis 35 % länger8. Diese Studie habe ich im Leitfaden zu TDD und BDD in Rails schon besprochen, deshalb hier der breitere Blick.
Eine Metaanalyse ist eine Studie, die die Ergebnisse vieler früherer Studien zusammenführt. Yahya Rafique und Vojislav Mišić haben 27 Studien zusammengeführt und kommen zu dem Ergebnis, dass TDD insgesamt einen kleinen positiven Effekt auf die Qualität hat und kaum einen erkennbaren Effekt auf die Produktivität. In den Studien aus der Industrie waren sowohl der Qualitätsgewinn als auch der Produktivitätsverlust größer als in den akademischen9. Die Belege zeigen also in eine vernünftige Richtung: Du zahlst vorne etwas mehr und bekommst weniger Fehler, und der Effekt ist echt, aber keine Zauberei.
Eine dritte Studie ist für die Praxis am nützlichsten. Davide Fucci und Kollegen haben den TDD Prozess zerlegt und gemessen, welche Teile zählen. Qualität und Produktivität hingen vor allem mit Granularität und Gleichmäßigkeit zusammen, also mit kleinen Schritten in ruhigem Takt. Ob in einer Runde der Test vor oder nach dem Code kam, hatte in ihren Daten keinen nennenswerten Einfluss10. Das macht die Reihenfolge nicht egal: Der rote Schritt bleibt der einzige Beweis, dass ein Test scheitern kann. Aber es zeigt, wo der Großteil des Nutzens steckt, nämlich in der kurzen Schleife und den Babyschritten.
Selbst die Leute, die die Methode geprägt haben, streiten über ihre Ränder. 2014 führten Kent Beck, Martin Fowler und David Heinemeier Hansson, der Erfinder von Rails, eine Reihe öffentlicher Gespräche unter dem Titel "Is TDD dead?". Heinemeier Hansson hielt dagegen, dass alles isoliert zu testen einem Entwurf schaden kann. Fowler hielt fest, dass TDD ein Weg zu selbsttestendem Code ist, nicht der einzige11. Beide Sichtweisen lohnen sich. Keiner von beiden hat dafür plädiert, ungetesteten Code auszuliefern.
Um eine Zahl wie "40 % geringere Fehlerdichte" zu verstehen, hilft es, sie aufzuschreiben. Die Fehlerdichte ist die Zahl der Fehler geteilt durch die Größe:
Dabei ist die Fehlerdichte, die Zahl der gefundenen Fehler und die Größe des Codes in tausend Zeilen. Die relative Senkung vergleicht die Dichte ohne TDD, , mit der Dichte mit TDD, . Diese Senkung ist eine prozentuale Veränderung, von Grund auf erklärt in Grundlagen: Prozente.
Beispiel: was "40 % weniger Fehler" praktisch heißt
Die Zahlen sind erfunden, um die Rechnung zu zeigen. Ein vergleichbares Shopprojekt mit 20.000 Zeilen hatte vor dem Start 150 gefundene Fehler. Das sind Fehler pro tausend Zeilen. Ein gleich großes Projekt, testgetrieben gebaut, hatte 90:
Also Fehler pro tausend Zeilen und , eine Senkung um 40 %. In einfachen Worten: Auf je zehn Fehler, die das erste Projekt vor dem Start finden und beheben musste, kamen beim zweiten sechs. Jeder der vier fehlenden Fehler ist ein Abend, an dem niemand debuggen muss, und manche davon hätte sonst die Kundschaft gefunden.
Wann sich TDD lohnt, und wann ein Spike in Ordnung ist
TDD lohnt sich am meisten dort, wo Code lange lebt, sich oft ändert und mit Geld, Regeln oder Daten umgeht, die stimmen müssen. Ein Rabattcode ist der Paradefall. Genauso die Umsatzsteuer, der Lagerbestand, die Verlängerung eines Abos, alles auf dem Weg, den eine Kundin bis zur Zahlung geht.
Am wenigsten lohnt es sich, wenn du noch nicht weißt, was du baust. Extreme Programming hat dafür einen Namen: den Spike. Don Wells beschreibt eine Spike Lösung als sehr einfaches Stück Code, um mögliche Lösungen zu erkunden, gebaut nur für das untersuchte Problem, und er ergänzt, dass die meisten Spikes nicht gut genug sind, um sie zu behalten, du also damit rechnen solltest, sie wegzuwerfen12. Wichtig ist genau der letzte Teil. Ein Spike beantwortet eine Frage, und dann geht er. Das Echte baust du testgetrieben neu, mit dem, was der Spike dir beigebracht hat.
Beispiel: das Quiz zur Teestärke
Das Teehaus will auf der Startseite ein kurzes Quiz, das je nach gewünschter Stärke einen Tee empfiehlt. Noch weiß niemand, wie viele Fragen es braucht oder wie die Antworten zu den Tees passen. Jana gibt sich einen Nachmittag und baut eine grobe Version ganz ohne Tests, nur um sie mit der Inhaberin und zwei Stammkundinnen auszuprobieren.
Es zeigt sich: Drei Fragen reichen völlig, und die nützlichste Frage ist die nach Milch, an die vorher niemand gedacht hat. Am nächsten Morgen löscht Jana den Spike Branch. Sie schreibt aus dem Gelernten eine Testliste ("mit Milch und kräftig ergibt Assam", "ohne Milch und mild ergibt Grüntee" und so weiter) und baut das echte Quiz testgetrieben. Der Nachmittag war nicht verloren. Er hat das Wissen gekauft, das es für eine gute Testliste braucht. Verloren wäre er gewesen, wenn der Spike mit all seinen Vermutungen und ohne Tests live gegangen und zwei Jahre lang weitergebaut worden wäre.
Was du als Inhaberin oder Inhaber verlangen solltest
Du musst kein Ruby lesen können, um zu erkennen, ob deine Software testgetrieben gebaut wird. Du musst nach den Belegen fragen, in einfachen Worten, und schauen, ob es sie gibt.
Die Fragen, die funktionieren, sind schlicht. Kann ich die Liste der Testnamen für das Feature sehen, das wir gerade vereinbart haben? Laufen die Tests bei jeder Änderung automatisch, und stoppt ein roter Test ein Release? Wenn wir im Meeting etwas entschieden haben, etwa die Regel mit dem halben Cent, wo ist der Test, der sie festhält? Wer testgetrieben arbeitet, antwortet darauf mit Links, nicht mit Beruhigung.
Das zählt umso mehr, seit KI Assistenten einen großen Teil des neuen Codes schreiben. Eine KI schreibt gern zuerst den Code und danach die Tests, oder passt einen Test so lange an, bis er grün ist. Eine mit einem Menschen vereinbarte Testliste und eine Schleife, in der der scheiternde Test zuerst kommt, lassen den Menschen bestimmen, was "richtig" heißt. Die Kapitel über testgetriebene Entwicklung mit KI und darüber, wenn die KI den Test statt den Code ändert, gehen dem im Detail nach.
Beispiel: drei Fragen der Inhaberin an Jana
Bevor WELCOME10 live geht, fragt die Inhaberin des Teehauses Jana drei Dinge.
"Zeig mir, was der Rabattcode tun soll." Jana schickt die sechs Testnamen. Die Inhaberin liest sie, vermisst nichts, wünscht sich aber einen siebten: Ein Code darf nicht auf die Abobox wirken, die schon rabattiert ist. Jana setzt ihn auf die Testliste, schreibt den roten Test, macht ihn grün. Zehn Minuten.
"Was passiert, wenn das später jemand ändert?" Jana zeigt, dass die Tests bei jeder Änderung laufen und ein roter Test das Release blockiert.
"Woher weiß ich, dass die Entscheidung mit dem Runden hält?" Jana zeigt auf den Test "rundet halbe Cent zugunsten des Shops ab". Die Inhaberin hat ihre Regel jetzt schriftlich, von einer Maschine geprüft, und die nächste Person im Code kann sie nicht still rückgängig machen.
So arbeite ich übrigens auch. Jedes Projekt, das ich in Ruby on Rails und Solidus baue, beginnt testgetrieben, mit Verhaltensszenarien obendrauf, die du als Kundin oder Kunde lesen kannst, und jedes Release geht durch eine Testschranke, bevor es die Kundschaft erreicht. Das nächste Kapitel über verhaltensgetriebene Entwicklung zeigt, wie aus dem Gespräch mit der Inhaberin solche Szenarien werden.
Fazit
Ein automatisierter Test ist eine aufgeschriebene Erwartung, die eine Maschine für dich prüft: die Lage vorbereiten, ausführen, die Antwort prüfen. TDD schreibt diese Erwartung zuerst, sieht sie aus dem richtigen Grund scheitern, schreibt gerade genug Code zum Bestehen und räumt auf, während alles grün bleibt. Eine Testliste hält die Schritte klein, Vortäuschen und Triangulieren halten sie ehrlich, und Namen, die Verhalten beschreiben, machen die Testdatei zu einer Spezifikation, die auch das Geschäft lesen kann.
Das kostet vorne etwas Zeit. Die Forschung sagt, dass es dafür weniger Fehler bringt und dass der meiste Nutzen in kleinen, gleichmäßigen Schritten steckt. Wenn du nicht weißt, was du bauen sollst, mach einen Spike, lern daraus und wirf ihn weg. Wenn der Code über Jahre Geld, Regeln oder Kundschaft trägt, schreib zuerst den Test. Es ist die Reihenfolge, die dich später deine Meinung ändern lässt, ohne deine Versprechen zu brechen.