Testgetriebene Entwicklung
Was ist testgetriebene Entwicklung (Test-Driven Development, TDD)?
Testgetriebene Entwicklung (Test-Driven Development, TDD), auch testgetriebenes Design genannt, ist eine Softwareprogrammiermethode, die Unit-Tests, Programmierung und Refactoring von Quellcode miteinander verknüpft. Die Hauptziele der testgetriebenen Entwicklung sind: die Entwicklung beschleunigen und qualitativ hochwertige Software liefern.
Kent Beck, ein amerikanischer Softwareentwickler, entwickelte die testgetriebene Entwicklung in den frühen 1990er Jahren als Teil des ebenfalls von ihm entwickelten Extreme Programming (XP). XP ist Teil der agilen Softwareentwicklungsmethodik, die von Entwicklungsteams weltweit mit großem Erfolg angewendet wird.
Testgetriebene Entwicklung wendet agile Prinzipien an, die weitgehend auf die Verkürzung des Entwicklungszyklus ausgerichtet sind. Es ist ein feedbackgesteuerter, testorientierter Entwicklungsansatz, bei dem Unit-Testfälle bereits vor der Entwicklung des Codes erstellt werden.
Bei der testgetriebenen Entwicklung treibt der Testprozess den Entwicklungsprozess voran, was bedeutet, dass Entwickler nur dann neuen Code schreiben oder bestehenden Code ändern müssen, wenn die Unit-Tests fehlschlagen. Wenn der Test fehlschlägt, schreiben sie den Code neu, damit er den Test besteht. Dieser testgetriebene Ansatz verhindert die Duplizierung von Testskripten und hilft Teams, optimierten, widerstandsfähigen Code und letztendlich qualitativ hochwertigere Software zu erstellen.
Schritte der testgetriebenen Entwicklung
Testgetriebene Entwicklung folgt einem systematischen agilen Ansatz, der festlegt, wie die Entwicklungsarbeit erfolgt.
Bevor neuer Code geschrieben wird, muss der Programmierer zunächst einen fehlgeschlagenen Unit-Test erstellen. Dann erstellt der Programmierer – oder das Paar oder die Gruppe – gerade so viel Code, wie erforderlich ist, um diese Anforderung zu erfüllen. Sobald der Test bestanden ist, kann der Programmierer den Code bereinigen und das Design umgestalten, um Verbesserungen vorzunehmen, ohne dessen Verhalten zu verändern.
So läuft der Prozess ab:
- Erstellen Sie eine Liste mit Testfällen.
- Schreiben Sie einen Test für jede neue Funktionalität, jedes neue Feature oder jede Änderung, die der Software hinzugefügt werden soll.
- Stellen Sie sicher, dass der Test fehlschlägt.
- Schreiben Sie den Code, bis der Test bestanden ist.
- Führen Sie die Testfälle erneut aus und überarbeiten Sie den Code, um Duplikate zu entfernen und seine Struktur zu verbessern.
- Stellen Sie den Code bereit.
- Wiederholen Sie den Prozess während der gesamten Entwicklung.
Testgetriebene Entwicklung im Vergleich zu anderen Entwicklungsansätzen
Der offensichtlichste Unterschied zwischen testgetriebener Entwicklung und älteren Entwicklungsansätzen ist die Reihenfolge von Entwicklung und Testen. Bei der testgetriebenen Entwicklung werden die Tests vor dem Code erstellt, während bei älteren Methoden das Testen erst nach der Entwicklung des Codes erfolgt. Wenn die Tests im Voraus bekannt sind, verbessert dies die Erstqualität.
Testgetriebene Entwicklung konzentriert sich auf die Interaktionen der Programmierer auf Modulebene. Es gibt andere beliebte Methoden, wie zum Beispiel akzeptanztestgetriebene Entwicklung (Acceptance Test–Driven Development, ATDD) oder verhaltensgetriebene Entwicklung (Behavior-Driven Development, BDD), die sich auf Tests konzentrieren, die für Kunden verständlich sind. Bei diesen Methoden arbeiten die technischen Mitarbeiter und der Kunde zusammen, um konkrete Beispiele als Tests zu erstellen, bevor der Code erstellt wird, und führen die Tests dann nach der Erstellung des Codes aus, um zu zeigen, dass der Code implementiert ist.
Akzeptanztestgetriebene Entwicklung und verhaltensgetriebene Entwicklung erfordern die Zusammenarbeit von Entwicklern, Testern und der Geschäftsseite, um sich vor der Erstellung des Codes ein Bild von der Software und ihren Auswirkungen zu machen und diese zu diskutieren. Im Gegensatz dazu erfordert testgetriebene Entwicklung nur die Zusammenarbeit von Entwicklungs- und Testteams bei der Erstellung von Testfällen und der Aktualisierung des Codes im Laufe der Entwicklung.
Vorteile der testgetriebenen Entwicklung
Mit testgetriebener Entwicklung lassen sich hochwertige Anwendungen schneller erstellen als mit älteren Methoden. Das liegt daran, dass die Tests ein kontinuierliches Feedback liefern, das die Entwicklungsteams sofort überprüfen und bearbeiten können, um die Codequalität zu verbessern.
Im Gegensatz zu traditionellen Entwicklungsansätzen ist testgetriebene Entwicklung ein iterativer Ansatz, der in kleineren, besser handhabbaren Schritten funktioniert und es den Teams ermöglicht, den Code kontinuierlich zu testen und die Qualität des Codes und letztlich das Endergebnis kontinuierlich zu verbessern. Sie können bei Bedarf neue Funktionen hinzufügen und testen, selbst in späteren Phasen der Entwicklung. Testgetriebene Entwicklung macht auch die Neuerstellung umfangreicher Testskripte überflüssig. Die Tests sind bereits vor Beginn der Entwicklung erstellt.
Die ordnungsgemäße Implementierung von testgetriebener Entwicklung erfordert, dass die Entwickler und Tester genau vorhersagen können, wie die Anwendung und ihre Funktionen in der Praxis funktionieren werden. Wenn sie dazu in der Lage sind, kann testgetriebene Entwicklung dazu beitragen, dass die Anwendung die definierten Anforderungen erfolgreich erfüllt und wie erwartet funktioniert.
Testgetriebene Entwicklung erstellt als Nebenprodukt eine Testsuite, die manuelle Tests durch Menschen minimieren kann, während Probleme früher erkannt werden, was zu schnelleren Korrekturen führt. Die methodische Natur der testgetriebenen Entwicklung und sein Fokus auf das Testen kleiner Codeeinheiten sorgen für eine viel höhere Testabdeckung und Erstqualität als klassische phasenweise Code-Test-Fix-Retest-Zyklen.
Da die Tests bereits zu Beginn des Designzyklus beginnen, unterstützt testgetriebene Entwicklung außerdem dabei, Fehler und Bugs frühzeitig zu identifizieren, was die Fehlersuche vereinfachen und beschleunigen und gleichzeitig die Kosten senken kann. Testgetriebene Entwicklung vereinfacht auch die Codewartung und hilft dabei, eine flexiblere und widerstandsfähigere Codebasis zu schaffen.
Schließlich können Teams, die testgetriebene Entwicklung einführen möchten, je nach ihren Anforderungen und Fähigkeiten aus mehreren Unit-Testing-Frameworks wählen. Sie können beispielsweise PyUnit zum Testen von Python-Projekten und csUnit für Microsoft .NET-Projekte verwenden. Es gibt auch Frameworks für Unit-Testing-Projekte, die in Java, Ruby und anderen Programmiersprachen geschrieben sind.
Nachteile der testgetriebenen Entwicklung
Testgetriebene Entwicklung ist möglicherweise nicht für große oder komplexe Projekte geeignet, bei denen es schwierig – und manchmal sogar unmöglich – ist, den Code in kleinen Schritten zu testen, bevor er in das System integriert werden kann.
Testgetriebene Entwicklung erfordert beträchtliche Fähigkeiten, um erfolgreich zu sein, insbesondere auf Modulebene. Viele Legacy-Systeme wurden nicht mit Blick auf Unit-Tests entwickelt, sodass eine Isolierung der zu testenden Komponenten unmöglich ist.
Vielen Programmierern fehlen die Fähigkeiten, um sauberen Code zu isolieren und zu erstellen. Jeder im Team muss die Unit-Tests erstellen und pflegen, da sie sonst schnell veralten. Ein Unternehmen, das testgetriebene Entwicklung in Betracht zieht, muss jetzt etwas langsamer vorgehen, um später schneller voranzukommen.
Schließlich sind die Endergebnisse der testgetriebenen Entwicklung, wie bei jeder Methode, nur so gut wie die verwendeten Tests, die Gründlichkeit, mit der sie durchgeführt wurden, und das Ausmaß, in dem sie die Bedingungen nachahmen, denen die Nutzer des Endprodukts wahrscheinlich begegnen werden.
