1 Testgetriebene Entwicklung
JavaScript ist eine dynamische Skriptsprache für Webapplikationen. Mit ihr können Sie von einer einfachen Formularvalidierung über kleine Anwendungen bis hin zu komplexen Webapplikationen, die umfangreiche Businessprozesse abbilden, alles umsetzen.
Ein zentrales Merkmal einer Webapplikation, das sie von einer gewöhnlichen Webseite unterscheidet, ist, dass sie eine gewisse Applikationslogik beinhaltet. Durch dieses programmierte Verhalten reagiert die Applikation auf bestimmte Ereignisse wie beispielsweise die Interaktion eines Benutzers. Je mehr Logik in einer Applikation enthalten ist, desto wahrscheinlicher wird es, dass sich Fehler einschleichen. Diesem Problem können Sie begegnen, indem Sie Ihre Software testen.
Hierfür existieren zahlreiche Möglichkeiten. Die einfachste besteht aus dem manuellen Testen Ihrer Applikation, d.h., Sie entwickeln eine neue Funktionalität, testen sie im Anschluss und lassen sie im nächsten Schritt von unabhängigen Testern prüfen. Die Schwachstelle von solch manuellen Tests ist, dass sie nur mit hohem Aufwand reproduzierbar sind. Das bedeutet: Wenn Sie ein neues Feature entwickelt haben, müssten Sie eigentlich sämtliche Funktionalität Ihrer Applikation überprüfen, um sicherzustellen, dass keine bestehende Funktionalität negativ beeinflusst wird. An dieser Stelle kommen automatisierte Tests ins Spiel.
In diesem Kapitel erfahren Sie mehr über die Hintergründe der testgetriebenen Entwicklung und welche Auswirkungen diese Methode auf Ihre tägliche Arbeit hat. Außerdem sehen Sie, welche Voraussetzungen Sie für erfolgreiche testgetriebene Entwicklung erfüllen müssen und welche Vorteile Ihnen daraus entstehen.
1.1 Was ist testgetriebene Entwicklung?
TDD
Bevor Sie sich weiter mit testgetriebener Entwicklung (engl. Test-Driven Development, TDD) beschäftigen, ist es zunächst hilfreich, wenn Sie eine klare Vorstellung haben, was dieser Begriff bedeutet und welche Konsequenzen der Einsatz dieser Methode mit sich bringt.
Bei der testgetriebenen Entwicklung schreiben Sie zuerst einen sogenannten Unit-Test und führen ihn aus. Dieser schlägt daraufhin fehl, da die Funktionalität noch nicht existiert. Danach entwickeln Sie den Teil der Software, der dafür sorgt, dass der Test erfolgreich durchlaufen kann. Im Anschluss daran können Sie Ihren Quellcode verbessern. Dieser letzte Schritt wird als Refactoring bezeichnet.
Unit-Test
Ein Unit-Test oder auch Modultest wird in der Softwareentwicklung angewendet, um die funktionalen Einzelteile (Module) von Computerprogrammen zu testen, d.h., sie auf korrekte Funktionalität zu prüfen.
(de.wikipedia.org/wiki/Modultest)
Testgetriebene Entwicklung ist eine Methode, die nicht auf eine bestimmte Plattform oder Programmiersprache beschränkt ist. Die einzige Voraussetzung, die Sie für testgetriebene Entwicklung erfüllen müssen, ist, dass Sie über ein Testframework verfügen. Diese existieren allerdings für beinahe jede Programmiersprache. So gibt es beispielsweise Implementierungen für C, Java und PHP. Aber auch JavaScript macht hier keine Ausnahme. Sowohl für clientseitiges JavaScript im Browser als auch für serverseitiges JavaScript, das beispielsweise mit Node.js umgesetzt wird, existieren verschiedene Frameworks, von denen Sie einige im Verlauf dieses Buchs näher kennenlernen werden.
Umdenken in der Entwicklung
Testgetriebene Entwicklung bedeutet in erster Linie ein Umdenken im Entwicklungsprozess. Statt wie gewohnt eine Funktionalität zu implementieren und diese danach zu testen, schreiben Sie bei der testgetriebenen Entwicklung zuerst den Test und danach die eigentliche Funktionalität. Wenn Sie das erste Mal mit testgetriebener Entwicklung in Berührung kommen, wird diese Herangehensweise sehr ungewohnt und umständlich für Sie sein. Auch werden Sie im Vergleich zur traditionellen Entwicklung ohne vorherige Tests viel langsamer sein.
Dieses Buch zeigt Ihnen, wie Sie diese Einstiegshürde überwinden und das Potenzial der testgetriebenen Entwicklung in JavaScript voll ausschöpfen können. Außerdem erfahren Sie, wie Sie mit verschiedensten Problemstellungen im Alltag umgehen können.
1.2 Woher kommt testgetriebene Entwicklung?
Zu Beginn eine gute Nachricht: Testgetriebene Entwicklung ist kein Modephänomen, das bald wieder verschwinden wird. Bereits im Jahr 1999 finden Sie Erwähnungen von testgetriebener Entwicklung im Werk von Kent Beck über Extreme Programming. Seine ersten Berührungen mit testgetriebener Entwicklung hatte Beck bei der Entwicklung des ersten Unit-Test-Frameworks der xUnit-Serie für Smalltalk mit dem Namen SUnit im Jahr 1994. In seinem Buch Kent Beck’s Guide to Better Smalltalk erwähnt er dieses Testframework zum ersten Mal.
Extreme Programming
Extreme Programming ist eine Methode der agilen Softwareentwicklung, in der testgetriebene Entwicklung von zentraler Bedeutung ist. Im Gegensatz zu Scrum und anderen agilen Methoden beschäftigt sich Extreme Programming mit überwiegend techniknahen Vorgehensweisen. Dabei wird zwischen insgesamt fünf Werten wie beispielsweise Kommunikation und Respekt, 14 Prinzipien, die unter anderem Qualität und kleine Schritte bei der Entwicklung umfassen, und schließlich zahlreichen Praktiken unterschieden. Eine dieser Praktiken, die Sie als Entwickler bei der agilen Softwareentwicklung einsetzen sollen, ist die testgetriebene Entwicklung. Weitere Praktiken, die der testgetriebenen Entwicklung recht nahestehen, sind beispielsweise Pair Programming oder Refactoring.
Das erste Buch zur testgetriebenen Entwicklung
2002 erschien ein Buch von Kent Beck mit dem Titel Test-Driven Development By Example, das sich ausschließlich dem Thema der testgetriebenen Entwicklung widmet. Dieses Buch bietet Ihnen als Leser durch die Verwendung eines anschaulichen Beispiels einen guten Einstieg in die Thematik. Im letzten Teil des Buchs erfahren Sie außerdem mehr über Patterns im Umgang mit Unit-Tests. Eine wichtige Lehre, die Sie aus diesem Buch ziehen können, ist, dass testgetriebene Entwicklung nicht für eine bestimmte Programmiersprache gilt, sondern das Konzept stattdessen allgemeingültig ist und in nahezu jeder Programmiersprache angewandt werden kann.
Frühere Erwähnungen von testgetriebener Entwicklung
Kent Beck ist allerdings nicht der Erfinder von testgetriebener Entwicklung. Vielmehr hat er diese Art der Programmierung wiederentdeckt und ihr zu neuem Glanz verholfen. Bereits in den 1960er-Jahren wurde testgetriebene Entwicklung im Mercury-Projekt der NASA eingesetzt. Bei dem Mercury-Projekt handelt es sich um das erste bemannte Weltraumprogramm der NASA. Hierbei wurde in sehr kurzen Zyklen von jeweils einem halben Tag entwickelt und das Ergebnis dann einem Review unterzogen.
Testgetriebene Entwicklung und JavaScript
Die ursprüngliche Variante der testgetriebenen Entwicklung von Kent Beck war für die Sprache Smalltalk gedacht. Durch den Erfolg dieser Methode wurde die testgetriebene Entwicklung allerdings recht schnell auch für andere Programmiersprachen wie beispielsweise Java übernommen. Der Einsatz von testgetriebener Entwicklung ist sehr eng an die Verfügbarkeit von Testframeworks geknüpft, die es Ihnen als Programmierer leichter machen, Tests zu schreiben. Diese Grundvoraussetzung ist auch in JavaScript gegeben. Sie können hier auf zahlreiche Testframeworks zurückgreifen. Mehr zum Thema Testframeworks erfahren Sie im zweiten Kapitel.
Da es sich bei der testgetriebenen Entwicklung um eine Methode handelt, die wie bereits erwähnt nicht an eine bestimmte Plattform oder Programmiersprache gebunden ist, können Sie diese Vorgehensweise auch in JavaScript einsetzen. Im Jahr 2010 hat Christian Johansen mit seinem Buch Test-Driven JavaScript Development das erste Werk veröffentlicht, das sich intensiv mit dem Thema der testgetriebenen Entwicklung in JavaScript auseinandersetzt. Seit dieser Zeit etabliert sich das Testen von JavaScript-Code zunehmend. Dies macht sich vor allem durch besser getestete Applikationen, aber auch durch die Anwendung von testgetriebener Entwicklung in JavaScript bemerkbar.
Im Folgenden erfahren Sie, wie die testgetriebene Entwicklung im Kern funktioniert.
1.3 Wie funktioniert testgetriebene Entwicklung?
Der testgetriebenen Entwicklung liegt ein recht einfaches Schema zugrunde: Red, Green, Refactor. Diese drei Begriffe beschreiben, wie Sie vorgehen, wenn Sie testgetrieben entwickeln.
Der erste Schritt, Red, besteht darin, dass Sie einen Test schreiben. Dieser Test muss fehlschlagen, da noch keinerlei Quellcode zur Problemlösung geschrieben wurde.
Das einzige Ziel des nächsten Schrittes, Green, besteht darin, dass der Test erfolgreich ablaufen kann. Sie müssen nun gerade so viel Quellcode schreiben, wie nötig ist, um den Test funktionsfähig zu machen.
Im dritten und letzten Schritt können Sie mit einem gezielten Refactoring Ihren Quellcode verbessern und Redundanzen entfernen.
Endlosschleife
Diese drei...
