Test Driven Development: Red-Green-Refactor

Test Driven Development, kurz TDD, ist eine Entwicklungspraxis, bei der Tests vor der Produktivcode geschrieben werden. Der bekannte Red-Green-Refactor-Zyklus zwingt Entwickler, sich vor der Implementierung über das gewünschte Verhalten klar zu werden. Das Ergebnis ist oft besserer, testbarer und fokussierter Code.

In a Nutshell

• TDD schreibt Tests vor dem Produktivcode.
• Der Zyklus besteht aus Red, Green und Refactor.
• Red: Test schreiben, der fehlschlägt.
• Green: Minimaler Code, damit der Test besteht.
• Refactor: Code verbessern, ohne das Verhalten zu ändern.
• TDD fördert kleine Schritte, klare Anforderungen und testbaren Code.

Kompakte Fachbeschreibung

TDD kehrt die traditionelle Reihenfolge um. Statt zuerst Code zu schreiben und später Tests zu ergänzen, beginnt der Entwickler mit einem fehlschlagenden Test. Dieser Test beschreibt das gewünschte Verhalten. Danach wird der kleinste mögliche Code geschrieben, der den Test erfüllt. Im letzten Schritt wird der Code bereinigt, ohne die Tests zu brechen.

Der Red-Green-Refactor Zyklus

Red

Schreibe einen Test für eine noch nicht implementierte Funktion. Führe den Test aus. Er muss fehlschlagen, sonst ist der Test nicht aussagekräftig.

Green

Schreibe den minimalen Code, der benötigt wird, damit der Test besteht. Eleganz spielt in diesem Schritt noch keine Rolle, das Ziel ist ein grüner Test.

Refactor

Bereinige den Code, entferne Duplikate, verbessere Namen und Struktur. Alle Tests müssen weiterhin grün bleiben.

Best Practices

• Kleine Schritte: Jeder Zyklus sollte wenige Minuten dauern.
• Fokus auf Verhalten: Tests beschreiben, was die Software tun soll, nicht wie sie es intern tut.
• Kein überflüssiger Code: Schreibe nur Code, der einen Test erfüllt.
• Refactor nicht überspringen: Der dritte Schritt ist essenziell für Clean Code.
• Tests lesbar halten: Tests dokumentieren die Absicht des Codes.

Praxisbeispiel: Rabattberechnung mit TDD

import unittest
from app.pricing import calculate_discount

class TestDiscount(unittest.TestCase):
    def test_no_discount_below_threshold(self):
        self.assertEqual(calculate_discount(50), 0)

    def test_discount_for_threshold(self):
        self.assertEqual(calculate_discount(100), 10)

    def test_higher_discount_for_large_amount(self):
        self.assertEqual(calculate_discount(200), 20)

if __name__ == '__main__':
    unittest.main()

def calculate_discount(amount):
    if amount >= 200:
        return 20
    if amount >= 100:
        return 10
    return 0

Vorteile und Nachteile

Vorteile

• Klarere Anforderungen: Tests zwingen dazu, das gewünschte Verhalten zu definieren.
• Schnelles Feedback: Fehler werden sofort erkannt.
• Bessere Code-Qualität: TDD fördert kleine, fokussierte Funktionen.
• Sicherheit beim Refactoring: Tests schützen vor Regressionen.
• Lebende Dokumentation: Tests zeigen, wie die Software verwendet werden soll.

Nachteile

• Lernkurve: TDD erfordert Übung und Disziplin.
• Anfangsaufwand: Der erste Schritt kostet mehr Zeit als herkömmliches Programmieren.
• Nicht für alles geeignet: Spikes, Prototypen oder explorative Entwicklung profitieren weniger.
• Falsche Tests: Schlecht geschriebene Tests führen zu schlechtem Design.

Prüfungsrelevante Stichpunkte

• Definition und Ziel von TDD.
• Die drei Phasen Red, Green, Refactor.
• Unterschied zwischen TDD und herkömmlichem Testen.
• Vorteile und Grenzen von TDD.
• Bedeutung von kleinen Schritten und Refactoring.

Typische Prüfungsfragen (mit Kurzantwort)

1. Was ist TDD? Eine Entwicklungspraxis, bei der Tests vor dem Produktivcode geschrieben werden.

2. Welche drei Phasen hat der TDD-Zyklus? Red, Green, Refactor.

3. Was passiert in der Red-Phase? Ein Test wird geschrieben, der fehlschlägt, weil die Funktion noch nicht existiert.

4. Was ist das Ziel der Green-Phase? Der kleinste Code, der den Test erfüllt.

5. Was ist ein Vorteil von TDD? Schnelles Feedback und bessere Testabdeckung durch kleine, fokussierte Schritte.

Wichtigste Quellen

1. https://www.agilealliance.org/glossary/tdd/
2. https://martinfowler.com/bliki/TestDrivenDevelopment.html
3. https://en.wikipedia.org/wiki/Test-driven_development

Weiter im Software Testing Lernpfad

Der nächste Artikel im Software Testing Lernpfad behandelt Behavior Driven Development — wie BDD die Kommunikation zwischen Entwicklern und Stakeholdern verbessert.