Wie wir im vorherigen Teil der Serie gesehen haben, gibt es verschiedene Ansätze, Software zu testen. Diesmal werden wir uns näher mit den Unit- oder auch Komponententests beschäftigen. Wenn im Kontext von Browseranwendungen der Begriff „Komponente“ verwendet wird, ist hiermit häufig ein UI-Element oder UI-Widget gemeint. Diese Elemente dienen in Browseranwendungen dazu, dem Nutzer Informationen anzuzeigen oder vom Nutzer in der Anwendung ausgeführte Aktionen entgegenzunehmen. Ein Datepicker fällt beispielsweise unter diese Definition.
In der Softwareentwicklung allgemein ist mit Komponente einfach eine logische Einheit von Code gemeint. Dies kann zum Beispiel eine Klasse sein, ein Enum, oder auch eine Funktion bzw. Methode. Im Rahmen dieses Artikels wollen wir mit dem Begriff Komponente die in der Softwareentwicklung allgemein übliche Bezeichnung verbinden. Im Fall von UI-Komponenten werden wir explizit das Präfix „UI“ verwenden.
Die Aufgabe von Unit-Tests ist es, die Funktionalität einer Komponente sicherzustellen. Dabei werden sowohl die Standardanwendungsfälle der Komponente abgetestet als auch mögliche Fehlerzustände überprüft, um auch dann eine korrekte Funktionalität der Komponente gewährleisten zu können. So lässt sich schnell überprüfen, ob die Komponente – etwa nach Änderungen im Quellcode oder auch bei Update von Framework- oder Browser-Versionen – weiterhin korrekt funktioniert. Fehler können auf diese Weise schnell und ohne aufwendige manuelle Tests sicht- und somit behebbar gemacht werden. Dadurch erhöht sich die Wartbarkeit des getesteten Codes automatisch. Tests, die bestehenden Code vor wieder auftretenden Fehlern schützen, werden auch Regressionstests genannt.
Umgekehrt ist es häufig so, dass sich bisher ungetesteter Code oft gleichzeitig als schlechter wiederverwendbar herausstellt. Das äußert sich vor allem in schlecht oder umständlich zu schreibenden Tests: Der Code hat eine geringe Isolation oder Kohärenz und scheint sich geradezu gegen den Einsatz von Tests zu wehren.Eine Eigenschaft von gut wiederverwendbarem Code ist, dass er sich auch gut in anderen Kontexten verwenden lässt als in dem, für den er entwickelt wurde. Dass sich die Wiederverwendbarkeit von Software durch das Schreiben von Tests erhöht, liegt somit auch daran, dass jeder Unit-Test bereits eine erste Wiederverwendung des bestehenden Codes ist!
Allgemein sind Unit-Tests darauf ausgerichtet, die Funktionalität einzelner Komponenten für sich zu testen. Wir sprechen auch davon, die Komponenten in Isolation zu testen. Das bedeutet vor allem, dass Abhängigkeiten, die die Komponenten besitzen, nicht mit getestet werden sollten. Stattdessen werden diese Abhängigkeiten in der Regel mit einer Fake-Logik ausgetauscht, man spricht auch von „mocken“. Im Speziellen ist es im UI sinnvoll, UI-Komponenten gut gegen ihre Abhängigkeiten zu isolieren. Das macht es leichter, die UI-Komponenten mit anderen Komponenten zu integrieren, steigert also die Wiederverwendbarkeit. Ferner sollte aus UI-Komponenten selbst kein direkter Zugriff auf Remote-Dienste stattfinden, da dies die Abhängigkeiten erhöht und zu einer starken Kopplung an den konkreten Einsatzzweck führt.
Eine Vorgehensweise, die zur Entwicklung von qualitativ hochwertiger Software ihren Fokus auf das Testen von Code legt, ist das Test-driven Development (TDD). Das Besondere an dieser Vorgehensweise ist, dass die Tests zuerst – noch vor der eigentlichen Funktionalität – geschrieben werden. Diese Tests dienen dann als Vorgabe für das Verhalten des neu zu implementierenden Codes. Der allgemeine, sich immer wiederholende Entwicklungsablauf beim Test-driven Development lässt sich dann folgendermaßen zusammenfassen:
Test schreiben (Tests schlagen fehl: ROT)
Geschäftscode schreiben/anpassen (Tests werden GRÜN)
Refactoring (Tests bleiben GRÜN)
Im letzten Artikel haben wir die Testpyramide kennengelernt. Unit-Tests stellen die Basis der Testpyramide dar (Abb. 1). Da eine Anwendung in der Regel viele verschiedene Komponenten mit verschiedenen Funktionalitäten enthält, sollten eher viele Unit-Tests geschrieben werden. Da jeder einzelne Unit-Test aber immer nur einen Aspekt einer einzelnen Komponente testet und somit relativ wenig Code ausgeführt wird, laufen Unit-Tests in der Regel dennoch schnell durch.
Abb. 1: Die Basis der Testpyramide bilden die schnellen Unit-TestsUnit-Tests sind die Tests, die mit dem zu testenden Code direkt interagieren. Die Tests werden daher als Teil der Codebasis entwickelt und versioniert. Zu jedem Test sollte der Zustand der Komponente sowohl vor als auch nach dem Test oder zumindest ein zu erwartendes Testresultat definiert werden. Das tatsächliche Testergebnis kann dann mit dem zu erwartenden Ergebnis verglichen werden. Aufgrund dieser detaillierten Beschreibung der Aufrufe und der daraus resultierenden Ausgaben oder auch Zustandsübergänge der Komponenten können gut geschriebene Unit-Tests als eine Art lebendige Dokumentation des getesteten Codes angesehen werden. Es gibt tatsächlich eine Menge Testing-Tools, die speziell auf dieses sogenannte Behaviour-driven Testing zugeschnitten sind, wie wir später im Artikel noch sehen werden.
Komponenten- und Unit-Tests
In der Testpyramide befinden wir uns mit den Unit-Tests im unteren Bereich. Wenn wir uns die einzelnen mit Unit-Tests abzudeckenden Programmteile näher ansehen, fällt allerdings auf, dass dieser Bereich seinerseits eine gewisse Unterteilung besitzt: Es gibt zum Beispiel kleinere Einheiten, etwa einzelne Funktionen oder einfache Klassen, die sich entsprechend einfach testen lassen. Diese befinden sich ganz am unteren Rand der Testpyramide.
Auf der anderen Seite gibt es komplexere Klassen oder, wie im Fall von Browseranwendungen, UI-Komponenten. Diese liegen am oberen Rand der Unit-Tests, da sie bereits einen gewissen integrativen Charakter haben: Bei UI-Komponenten muss immer auch die Interaktion der Komponentenlogik mit der View (z. B. in Form des Browser-DOM) oder auch mit anderen UI-Komponenten bedacht und gegebenenfalls mit getestet werden. In Abbildung 2 ist beispielhaft der Aufbau der Datepicker-Kalender-Komponente aus der Angular-Material-Bibliothek dargestellt. Diese Komponente bindet ihrerseits einige weitere Komponenten ein, unter anderem eine Kalender-Header-Komponente und eine Month-View-Komponente, die wiederum einen Kalender-Body enthält. In Abbildung 3 ist der (stark vereinfachte) DOM-Baum gezeigt, der sich aus dieser Komponentenstruktur zur Laufzeit im Browser ergibt. Auch hier sieht man, dass die Kalenderkomponente die anderen Komponenten einbindet, also schon eine gewisse Integration leistet.
Viele UI-Komponenten benötigen ferner eine Möglichkeit, Fachlogik aufzurufen. Im Fall von Angular werden hierfür Services verwendet, die den Komponenten per Dependency Injection zur Verfügung gestellt werden. Um diese Services im Rahmen der der Unit-Tests nicht „aus Versehen“ mitzutesten bzw. keine Abhängigkeit auf mögliche Umsysteme im Test zu haben, müssen sie in der Regel durch Fake-Services ausgetauscht werden.
Abb. 2: Angular-Material-Kalenderkomponente, aufgeteilt in Unterkomponenten
Abb. 3: Vereinfachte Darstellung des Komponentenbaums im DOMKlassische Anwendungen
Klassische Webanwendungen zeichnen sich dadurch aus, dass im Client wenig bis keine Logik vorhanden ist. Sowohl Fachlogik als auch Rendering der View werden auf dem Server implementiert, der Browser des Nutzers dient lediglich der Anzeige der serverseitig gerenderten...

