Unit Tests und testbarer Code
Unit Tests sind in aller Munde. Es gibt wohl keinen Entwickler, der nicht davon gehört hat, dass Unit Tests ein Sicherheitsnetz bilden, das den Programmierer vor ungewollten Seiteneffekten seiner Änderungen schützen soll. In der täglichen Praxis erweisen sich Unit Tests jedoch oft, gerade bei Änderungen, als Hemmnis. Die Ursache liegt in der engen Beziehung zwischen Unit Tests und dem produktiven Code, den sie testen. Im Folgenden wird beschrieben, welche Eigenschaften Unit Tests und produktiver Code haben sollten, damit sie optimal zueinanderpassen. Ein Beispiel verdeutlicht diese Beziehung.
Unit Tests sind unbestrittenermaßen eine gute Sache. Auf der anderen Seite kennt aber jeder Programmierer auch die Situation, in der die Unit Tests, die ihm bei Änderungen eigentlich Probleme vom Hals halten sollen, mehr Arbeit verursachen als die beabsichtigte Änderung im produktiven Code. Worin liegt die Ursache für diese Schwierigkeiten? Dafür verantwortlich ist ein oft unterschätztes Phänomen: Unit Tests und der produktive Code, den sie testen, haben eine enge Beziehung. Der Produktivcode muss bestimmte Eigenschaften aufweisen, damit „gute“ Unit Tests dafür geschrieben werden können.
Was sind „gute“ Unit Tests?
Um diese Frage beantworten zu können, müssen wir die Begriffe „Unit“ und „Unit Test“ selbst genauer definieren. Im Allgemeinen wird eine Unit als abgeschlossener Bereich des produktiven Codes betrachtet. In einer objektorientierten Programmiersprache ist das beispielsweise eine Klasse oder eine Methode. Ein Unit Test ist dementsprechend ein Bereich des Testcodes, der eine Unit aufruft und deren Ausgaben prüft.
Leider hilft diese Definition noch nicht dabei, bessere Unit Tests zu schreiben, denn sie sagt nichts darüber aus, wie komplex so eine Unit sein darf. Eine Definition, die hier mehr Klarheit schafft, stammt von Roy Osherove [1]. Er definiert eine Unit als Teil des produktiven Codes, der eine isolierte Funktionalität realisiert. Daraus folgt seine Definition des Unit Tests als Teil des Testcodes, der eine einzelne isolierte Funktionalität im produktiven Code prüft.
Ausgehend von dieser Definition müssen Unit Tests Eigenschaften haben, die sich, ins Englische übersetzt, mit dem altbekannten Akronym RTFM zusammenfassen lassen. Ausgeschrieben bedeutet es: Readable (lesbar), Trustwothy (vertrauenswürdig), Fast (schnell) und Maintainable (wartbar). Unter [2] werden diese Anforderungen ausführlicher erörtert. Auf dem Weg zu einer besseren Qualität ist insbesondere die Wartbarkeit der Unit Tests von entscheidender Bedeutung. Diese soll daher im Folgenden näher untersucht werden. Alle anderen Eigenschaften der Unit Tests kommen erst dann zum Tragen, wenn man wirklich etwas kaputtgemacht hat. Und das sollte nicht bei jeder Änderung passieren.
„Böser“ produktiver Code?
In welcher Weise beeinflusst nun der produktive Code die Wartbarkeit seiner Unit Tests? Dreh- und Angelpunkt sind die wesentlichen Prinzipien der objektorientierten Programmierung: Single Responsibility Pattern (SRP), Separation of Concerns (SoC) und Inversion of Control (IoC). Für produktiven Code, der gegen diese Prinzipien verstößt, kann man keine Unit Tests schreiben, die ihrerseits vollständig die RTFM-Anforderungen erfüllen.
Was aber haben SRP, SoC und IoC im produktiven Code mit der Wartbarkeit der Unit Tests zu tun? Der Zusammenhang ergibt sich aus der entstehenden Komplexität der zu testenden Einheit und der Unmöglichkeit, einzelne Funktionalitäten zum Testzeitpunkt gezielt von außen zu steuern. Diese äußere Kontrolle einzelner Funktionalitäten ist notwendig, um sicherzustellen, dass diese „externen“ Units das Testergebnis nicht verfälschen, falls diese sich (absichtlich oder nicht) ändert.
Ein Beispiel
Stellen wir uns vor, ein Kunde möchte, dass wir das Regelwerk für Conway’s Game of Life implementieren, wie es bei Wikipedia [3] beschrieben ist. Betrachten wir den ersten Entwurf in Listing 1: Eine Klasse Spiel mit der Methode berechneGeneration(String karte), die aufgrund der als Parameter übergebenen Karte des aktuellen Spielfelds die neue Karte für die nächste Generation berechnet und für die Anzeige an den Aufrufer zurückgibt. In dem String, der die Karte repräsentiert, bedeutet ein „X“ eine lebende Zelle und ein „.“ eine tote.
In Listing 2 befinden sich die Tests, die für die erste Implementierung geschrieben wurden. Alle Testmethoden werden erfolgreich ausgeführt (Abb. 1).
Abb. 1: Erfolgreiche Ausführung der TestsListing 1: Beispielimplementierung „Conway’s Spiel des Lebens“
class Spiel {
String berechneGeneration(String zellenMap) {
StringBuilder neueMap = new StringBuilder();
String[] mapRows =...
