TDD ist Design, ein fehlschlagender Test nach dem anderen

8 Min. Lesezeit

Das Ticket hat das Lager vergessen

17.11.2026, Von Stephan Schwab

Stephan Schwab

Ein Kunde klickt auf „Stornieren“, während im Lager jemand die Ware für seine Bestellung zusammensucht. Die Software meldet: storniert. Im Lager hat niemand bestätigt, dass die Arbeit gestoppt wurde. Eine kleine Funktion hat gerade ein Versprechen abgegeben, das der Betrieb nicht halten kann. In einem Python-Beispiel macht ein fehlschlagender Test sichtbar, was noch entschieden werden muss: Was soll der Kunde sehen, solange das Lager weiterarbeitet? Sobald der Test besteht, steht die Entscheidung im Code. Der nächste fehlschlagende Test zeigt, was wir immer noch falsch verstanden haben.

Ein Entwickler hört aufmerksam zu, während eine Lagerkollegin neben einem Laptop und einer Skizze im Notizbuch auf eine stornierte Kundenbestellung zeigt.
Die entscheidende Frage zum Design stellte die Kollegin, die die Bestellung stoppen müsste.

Ein Beispiel reicht, und die Diskussion läuft

Mit dem ersten Test legen wir eine Schnittstelle und ein Verhalten fest. Beides sind Designentscheidungen.

Nehmen wir ein bewusst kleines, erfundenes Bestellsystem. Solange die Bestellung im Lager auf Bearbeitung wartet, lässt sie sich sofort stornieren. Was gilt, sobald jemand die Ware zusammensucht? Darüber haben wir uns noch nicht geeinigt.

Schreib das erste Beispiel in test_order.py.

import unittest

from order import Order, cancel


class CancellationTests(unittest.TestCase):
    def test_waiting_order_can_be_cancelled(self):
        order = Order(state="waiting")

        result = cancel(order)

        self.assertEqual("cancelled", result.state)

Verwende eine aktuell unterstützte Python-3-Version. Starte den Testläufer unittest aus der Standardbibliothek im Verzeichnis mit den Beispieldateien.

python3 -m unittest -v

Zuerst scheitert der Import, weil order.py fehlt. Leg die Datei mit gerade genug Code an, damit der Test das gewünschte Verhalten erreichen kann.

from dataclasses import dataclass


@dataclass(frozen=True)
class Order:
    state: str


def cancel(order: Order) -> Order:
    raise NotImplementedError

Führ den Test noch einmal aus. Er erreicht jetzt cancel und scheitert mit NotImplementedError. Damit wissen wir, warum er rot ist. Ein Tippfehler im Import würde uns etwas über unsere Rechtschreibung verraten. Dieser Fehler zeigt, dass die Stornierung noch nicht implementiert ist.

Schau, was bereits entschieden ist. Die Stornierung ist eine Operation auf einer Bestellung. Sie liefert eine Bestellung zurück, deren Zustand wir prüfen können. Die Eingabe ist ein unveränderlicher Wert. Wer die ursprüngliche Bestellung behält, muss also nicht befürchten, dass sie sich hinter seinem Rücken ändert. Ein veränderliches Objekt oder ein Command-Handler wären ebenfalls möglich gewesen. Der Test zwingt uns, eine Variante auszuprobieren.

Ersetze nun den Import in order.py durch from dataclasses import dataclass, replace. Lass die Klasse Order stehen und ersetze cancel durch diese Funktion.

def cancel(order: Order) -> Order:
    return replace(order, state="cancelled")

Der Test ist grün. Die Implementierung erfüllt unser einziges Beispiel. Bei Bestellungen, die schon auf dem Weg nach draußen sind, liegt sie daneben.

Gut, wenn einem der Unterschied auffällt, solange das Programm noch auf einen Bildschirm passt.

Für den zweiten Test brauchen wir eine Antwort aus dem Lager

Ein automatisierter Test kann eine fachliche Entscheidung festhalten. Treffen müssen sie die Verantwortlichen.

Frag die Kollegin im Lager, was Stornieren bedeutet, sobald die Kommissionierung läuft. Einen sofortigen Stopp kann sie nicht versprechen. Vielleicht steht der Mitarbeiter gerade nicht am Gerät. Der Vertrieb stimmt zu, dass der Kunde zunächst eine Stornoanfrage sehen soll. Das Lager muss den Stopp erst bestätigen. Ist die Bestellung schon verschickt, muss der Kunde sie zurücksenden.

Diese Regeln gelten für unser Beispiel. Ein anderer Betrieb kann sich anders entscheiden. Der Entwickler sollte die Frage nicht nebenbei mit dem nächstbesten if beantworten.

Füge in test_order.py die beiden Methoden in CancellationTests ein.

    def test_picking_order_records_a_request(self):
        order = Order(state="picking")

        result = cancel(order)

        self.assertEqual("cancellation_requested", result.state)

    def test_shipped_order_remains_shipped(self):
        order = Order(state="shipped")

        result = cancel(order)

        self.assertEqual("shipped", result.state)

Lass die Tests laufen. Das erste Beispiel bleibt grün. Die beiden neuen schlagen fehl, weil die Funktion aus allem cancelled macht. So eine Blamage kann man gebrauchen. Das falsche Versprechen fällt uns auf, bevor der Kunde es per E-Mail bekommt.

Ändere die Funktion.

def cancel(order: Order) -> Order:
    if order.state == "picking":
        return replace(order, state="cancellation_requested")
    if order.state == "shipped":
        return order
    return replace(order, state="cancelled")

Drei Beispiele sind grün. Die nächste Frage ist schon da.

Was passiert, wenn der Kunde zweimal klickt, während im Lager weiter kommissioniert wird? Unsere Funktion macht aus cancellation_requested den Zustand cancelled. Der zweite Klick ersetzt plötzlich die Bestätigung aus dem Lager. Sehr effizient. Völlig aus der Luft gegriffen.

Füge das Beispiel für den zweiten Klick in CancellationTests ein.

    def test_repeated_request_does_not_confirm_cancellation(self):
        order = Order(state="cancellation_requested")

        result = cancel(order)

        self.assertEqual("cancellation_requested", result.state)

Schau zu, wie der Test fehlschlägt. Ersetze in cancel die Zeile if order.state == "shipped": durch if order.state in ("shipped", "cancellation_requested"): und lass die Tests erneut laufen. Die wiederholte Anfrage lässt den Zustand jetzt unverändert. Ergänze einen fünften Test, der eine bereits stornierte Bestellung übergibt und cancelled erwartet. Der sollte sofort grün sein. Das Verhalten war schon da. Jetzt steht es ausdrücklich in einem Test.

Beim Refactoring bekommt die Regel eine klare Form

Mit grünen Tests können wir die Darstellung verbessern, ohne das vereinbarte Verhalten neu auszuhandeln.

Die Bedingungen beschreiben inzwischen eine kleine Regel für Zustandsübergänge. Wer Zustände immer wieder als Zeichenketten eintippt, kann sich leicht verschreiben. Und der letzte Zweig behandelt stillschweigend jeden unbekannten Zustand als stornierbar. Gib den bekannten Zuständen feste Namen und liste die möglichen Ergebnisse einer Stornierung auf.

Ersetze die bisherige Version von order.py vollständig durch diese Fassung.

from dataclasses import dataclass, replace
from enum import Enum


class State(Enum):
    WAITING = "waiting"
    PICKING = "picking"
    CANCELLATION_REQUESTED = "cancellation_requested"
    CANCELLED = "cancelled"
    SHIPPED = "shipped"


@dataclass(frozen=True)
class Order:
    state: State


CANCELLATION_OUTCOME = {
    State.WAITING: State.CANCELLED,
    State.PICKING: State.CANCELLATION_REQUESTED,
    State.CANCELLATION_REQUESTED: State.CANCELLATION_REQUESTED,
    State.CANCELLED: State.CANCELLED,
    State.SHIPPED: State.SHIPPED,
}


def cancel(order: Order) -> Order:
    return replace(order, state=CANCELLATION_OUTCOME[order.state])

Die Tabelle ist eine Designentscheidung, über die man reden kann. Bei fünf Zuständen wären ausgeschriebene Bedingungen ebenfalls gut lesbar. Mit der Tabelle können der Entwickler und die Kollegin aus dem Lager alle Ergebnisse an einer Stelle prüfen. Die fünf vereinbarten Ergebnisse bleiben gleich. Für unbekannte Zustände entfällt bewusst das bisherige Standardverhalten. Fehlt der Eintrag, löst der Zugriff jetzt einen KeyError aus. Eingaben von außen muss die Anwendung weiterhin an ihrer Grenze prüfen. Eine Typannotation in Python übernimmt das nicht.

Ersetze test_order.py durch die vollständige Testsammlung unten. Die Beispiele verwenden nun die benannten Zustände und prüfen weiterhin das zuvor vereinbarte Verhalten.

import unittest

from order import Order, State, cancel


class CancellationTests(unittest.TestCase):
    def test_waiting_order_can_be_cancelled(self):
        order = Order(State.WAITING)

        result = cancel(order)

        self.assertEqual(State.CANCELLED, result.state)
        self.assertEqual(State.WAITING, order.state)

    def test_picking_order_records_a_request(self):
        result = cancel(Order(State.PICKING))

        self.assertEqual(State.CANCELLATION_REQUESTED, result.state)

    def test_shipped_order_remains_shipped(self):
        result = cancel(Order(State.SHIPPED))

        self.assertEqual(State.SHIPPED, result.state)

    def test_repeated_request_does_not_confirm_cancellation(self):
        order = Order(State.CANCELLATION_REQUESTED)

        result = cancel(order)

        self.assertEqual(State.CANCELLATION_REQUESTED, result.state)

    def test_cancelled_order_stays_cancelled(self):
        result = cancel(Order(State.CANCELLED))

        self.assertEqual(State.CANCELLED, result.state)

Führe denselben Befehl noch einmal aus. Alle fünf Tests sollten grün sein. Keine zusätzliche Testbibliothek, kein Webframework, keine Datenbank. Für eine einzelne Regel müssen wir nicht die ganze Anwendung einbestellen.

Der Zyklus Rot, Grün, Refactoring verbindet Implementierung und Design durch unmittelbare Rückmeldung. Die TDD-Definition der Agile Alliance zählt Design durch Refactoring ausdrücklich dazu. Nachträglich geschriebene Tests können das Verhalten einer fertigen Implementierung prüfen. Die Entdeckungen auf dem Weg dahin lassen sich damit nicht nachholen.

Die Datenbank hat unsere Unit-Tests nicht gelesen

Auch wenn der Zustandswechsel im Speicher stimmt, können sich Schreibzugriffe in die Quere kommen oder Nachrichten verloren gehen.

Unsere Funktion geht davon aus, dass der übergebene Zustand aktuell ist. Im Betrieb kann das Lager mit der Kommissionierung beginnen, nachdem die Anwendung waiting gelesen, aber bevor sie cancelled gespeichert hat. Ein grüner Unit-Test verrät uns nicht, ob das System mit diesem Wettlauf zurechtkommt.

Die Anwendung muss den Zustandswechsel davon abhängig machen, dass die gespeicherte Version noch der gelesenen entspricht. Einen Konflikt muss sie ausdrücklich behandeln. Je nach Datenbank und Aufbau kann dafür eine bedingte Aktualisierung oder eine Transaktion infrage kommen. Prüfe diesen Übergang mit der echten Datenbank, auch bei konkurrierenden Schreibzugriffen.

Die Bestätigung aus dem Lager braucht einen eigenen Übergang und eigene Beispiele. Dasselbe gilt für Zahlungsänderungen, Bestandsreservierungen und den Versand. Muss eine Änderung auch eine zuverlässig zugestellte Nachricht auslösen, prüfe den Fall, dass das Speichern klappt und das Senden scheitert. Eine wiederholte Nachricht darf keine zweite Rückerstattung auslösen. All das liegt außerhalb der kleinen Funktion von oben.

Auch die Oberfläche muss zwischen den Ergebnissen unterscheiden. Kommt eine Bestellung mit SHIPPED zurück, darf sie keine muntere Stornobestätigung anzeigen. Die Funktion lässt den Zustand stehen. Was der Kunde zu hören bekommt, ist eine eigene Frage.

Auch diese Schnittstellen lassen sich testgetrieben entwickeln. Fünf Unit-Tests bescheinigen noch keine Produktionsreife. Wer seine Tests nie auf die Datenbank loslässt, kann erstaunlich optimistisch bleiben.

Fertiges Design ist eine teure Fiktion

Verteile die Aufgaben, wo es hilft. Neue Erkenntnisse müssen frühere Entscheidungen ändern können.

Stell dir einen Ablauf vor, in dem zuerst die Analyse abgeschlossen und dann das Design freigegeben wird. Anschließend implementieren die Entwickler, und zum Schluss prüft jemand das Ergebnis. Die Frage nach der Stornierung taucht mitten in der Implementierung auf. Im genehmigten Design stehen nur waiting, cancelled und shipped.

Jetzt muss jemand entscheiden, ob ein fehlender Zustand eine nützliche Erkenntnis oder eine unzulässige Abweichung ist. Wenn sich das Dokument erst in einer Sitzung nächsten Donnerstag ändern lässt, hat die Organisation das Wegsehen billiger gemacht als das Verstehen.

Verschiedene Leute bringen verschiedenes Fachwissen mit. Architekturvorgaben können schon vor einer kleinen Funktion feststehen. Ein reguliertes System kann ausdrückliche Nachweise und Freigaben verlangen. Das alles lässt Raum für neue Erkenntnisse, auch wenn eine Phase schon als abgeschlossen gilt.

Die Kollegin aus dem Lager wusste etwas, das im Ticket fehlte. Die Tests gaben diesem Wissen eine präzise Form. Bei der Implementierung tauchte die nächste Frage auf, die nach der wiederholten Anfrage. Das Refactoring machte die entstandene Regel leichter überprüfbar. Jeder Schritt änderte, was der nächste leisten musste.

Darum ist Softwareentwicklung Design. Ein Diagramm kann eine wichtige Entscheidung festhalten. Ob sie zur Wirklichkeit passt, zeigt sich auch dann noch, wenn der Code anfängt, Widerworte zu geben.

Halte die Schritte so klein, dass du mit der Rückmeldung etwas anfangen kannst. Schreib das nächste Beispiel. Lass es aus einem Grund fehlschlagen, den du verstehst. Bring es zum Bestehen. Verbessere das Design und halte dich dabei an die vereinbarte Regel.

Und wenn das Lager eine unbequeme Frage stellt, rück einen Stuhl heran. Das Ticket hätte sie dir nie beantwortet.

Die Lage durchsprechen

Schildern Sie, was passiert. Ich höre zu, stelle ein paar praktische Fragen und spiegele zurück, was ich sehe: wo das Risiko liegen könnte, was Delivery blockiert und was als Nächstes prüfenswert aussieht. Kein Pitch, keine Verpflichtung. Vertraulich und direkt.

Gespräch beginnen

Newsletter: Kein Methoden-Theater. Kein Fluff.
Einblicke in echte Software-Auslieferung und Führung.

×