Beim Testframework JUnit hat vor Kurzem die Entwicklung der grundlegend überarbeiteten Version 5 begonnen. Wir werfen in diesem Artikel einen ersten Blick auf die geplanten Konzepte und Features. Hier gibt es interessante Neuerungen sowohl für Toolhersteller als auch für Entwickler. Zurzeit wird im Rahmen des JUnit-Lambda-Projekts an einem Alpha-Release gearbeitet. Ein idealer Zeitpunkt also, um noch eigenes Feedback und Anregungen in die Entwicklung des nächsten großen Releases einzubringen.
Das Testframework JUnit wurde ursprünglich im Jahr 2000 in der ersten Version veröffentlicht, von Kent Beck und Erich Gamma der Legende nach im Flugzeug per Pair Programming entwickelt [1]. JUnit war Vorbild für viele andere Testframeworks und wurde auf zahlreiche andere Plattformen portiert. Nach einer Untersuchung von Ende 2013 [2] ist JUnit (neben Logging-Frameworks) die am meisten verwendete Java-Bibliothek überhaupt. 43 Millionen Downloads allein in 2014 belegen diesen besonderen Status zusätzlich.
Nach vielen Jahren der Weiterentwicklung und Wartung ist JUnit mittlerweile bei Version 4.12 angelangt. Im Lauf dieser Wartungsarbeiten zeigte sich, dass es an der Zeit war, über die fünfte Generation von JUnit nachzudenken. Zum einen, weil die vorherigen Versionen aus Gründen der Rückwärtskompatibilität keine Sprachfeatures von Java 8 unterstützen konnten, zum anderen, weil die zur Verfügung stehenden Konstrukte die Komponierbarkeit von Erweiterungen erschwerten. Nicht zuletzt ist die Art und Weise, in der IDEs JUnit integrieren, hinderlich für die Weiterentwicklung.
Da es sich bei dieser Neukonzeption um ein größeres Unterfangen handelt, wurde zur Mitfinanzierung des JUnit-Lambda-Projekts eine Crowdfunding-Kampagne ins Leben gerufen [3]. Hierbei konnte mehr als das Doppelte des ursprünglich anvisierten Minimalbudgets erzielt werden. Insbesondere zeigt aber die hohe Zahl von 474 Unterstützern das große Interesse der Community an der Vision des JUnit-Lambda-Projekts. Neben 428 privaten Personen haben 36 Unternehmen, darunter große Anwender, insbesondere aber auch Hersteller von Entwicklungswerkzeugen, ihren Anteil beigetragen. Mit diesem Rückhalt fand im Oktober 2015 das Kick-off-Treffen in Karlsruhe statt, bei dem die Anforderungen bezüglich Integrierbarkeit mit den Herstellern von Gradle, Eclipse und IntelliJ IDEA, sowie mit Pivotal, dem Hersteller des Spring Frameworks, diskutiert wurden.
Bald nach dem Workshop wurde der Prototyp für JUnit Lambda vorgestellt, um Feedback der Community einzuholen [4]. Auf Basis dieses Feedbacks wird zurzeit die Version JUnit 5 Alpha M1 entwickelt. Auf diese Version bezieht sich auch der vorliegende Artikel. Es liegt in der Natur der Sache, dass sich API und darunterliegende Konzepte noch ändern können. Im Folgenden werden wir einen ersten Überblick über die neue Gesamtarchitektur, das Programmiermodell und das zugehörige API sowie die Themen Erweiterbarkeit und Integrierbarkeit geben.
Grundlegende Architektur
Eines der Hauptziele von JUnit 5 ist die Entkopplung des API zum Schreiben von Tests von dem API zum Ausführen der Tests. In JUnit 4 sind beide in einem Artefakt enthalten. Alle, die JUnit auf irgendeine Weise verwenden, hängen von diesem ab – egal ob es sich dabei um IDEs, Build-Tools, andere Testing-Frameworks oder Benutzer, die Tests schreiben, handelt. Diese Verwender benutzen teilweise Interna von JUnit, etwa interne Klassen oder private Instanzvariablen, die gar per Reflection ausgelesen werden. Die Weiterentwicklung von JUnit 4 wurde dadurch immens erschwert, in Teilen sogar nahezu unmöglich gemacht.
Abb. 1: JUnit-5-ModuleUm dieses Problem in Zukunft zu vermeiden, ist JUnit 5 in verschiedene Module aufgeteilt (Abb. 1). Zum Schreiben von Tests benötigt man lediglich das Modul junit5-api, in dem alle Annotations wie etwa @Test, grundlegende Assertions etc. enthalten sind. Build-Tools und IDEs verwenden junit-launcher zum Ausführen von Tests. Der darin enthaltene Launcher orchestriert das Auffinden und die Ausführung von Tests durch verschiedene Engines. Die Engine-Abstraktion ermöglicht die Ausführung von JUnit-4- und JUnit-5-Testfällen im selben Testlauf. Die Engines registrieren sich über den ServiceLoader-Mechanismus beim Launcher. Die Engine-Implementierungen hängen dabei nur vom Artefakt junit-engine-api ab. JUnit 5 wird zwei Engines mitliefern: junit4-engine und junit5-engine zum Auffinden und Ausführen von JUnit-4- bzw. JUnit-5-Tests. Das Engine-API ist zugleich ein Angebot an existierende und zukünftige Testing-Frameworks. Wenn sie eine Engine-Implementierung bereitstellen, können ihre Tests in allen IDEs und Build-Tools laufen, die JUnit 5 unterstützen.
Programmiermodell und Test-API
Die hier vorgestellten Beispiele basieren auf dem Milestone Alpha M1. Bis zum ersten JUnit-5-Release können sich daher noch Veränderungen ergeben. Tests in JUnit 5 (Listing 1) sehen den Tests aus der vorherigen Version sehr ähnlich. Auf den ersten Blick ist fast kein Unterschied zu erkennen. Diese Entscheidung wurde bewusst getroffen, damit der Umstieg zu JUnit 5 leicht fällt.
Listing 1: Einfacher Testfall
class SinglePassingTestSampleClass {
@Test
void singlePassingTest() {
System.out.println("Test got executed!");
}
}Im Detail sind dennoch maßgebliche Veränderungen sichtbar. So ist es nicht mehr notwendig, dass Testklassen und Testmethoden mit dem Keyword public versehen werden, um den Testcode schlanker zu machen.
Alle Annotationen für JUnit 5 befinden sich in einem eigenen Package namens org.junit.gen5.api. Spätestens nach einem Blick in dieses Package wird ersichtlich, dass es im Kern deutliche Unterschiede und Verbesserungen zu JUnit 4 gibt, auf die nun im Detail eingegangen wird.
Jeder Testklasse und jeder Testmethode kann ein selbstdefinierter Name (Listing 2) zugewiesen werden. Dieser Name wird im Ergebnis anstelle des Klassen- oder Methodennamens als Beschreibung angezeigt und erlaubt auch den Einsatz von Leer- und Sonderzeichen.
Listing 2: Erweiterte „Before“-/„After“-Annotationen
@Name("My custom test-class name")
class AdvancedSinglePassingTestSampleClass {
@BeforeAll
static void myBeforeAllMethod() {
// executed once before the first
// test method in this test class
}
@AfterAll
static void myAfterAllMethod() {
// executed once after the last
// test method in this test class
}
@BeforeEach
void myBeforeEachMethod() {
// executed before each
// test method in this test class
}
@AfterEach
void myAfterEachMethod() {
// executed after each
// test method in this test class
}
@Test
@Name("My custom test-method name")
void singlePassingTest() {
System.out.println("Test got executed!");
}
}Listing 2 zeigt eine Erweiterung hinsichtlich der Before-/After-Methoden. Die Codeausführungen vor und nach jedem Test werden weiterhin unterstützt und sind durch die Verwendung von BeforeAll, BeforeEach, AfterEach und AfterAll nun expliziter in der Ausdrucksweise der Annotationen. Das Verhalten der Methoden entspricht exakt dem heutigen Prinzip von JUnit 4.
Die Ausführung von Tests kann in JUnit 4 mit der Annotation @Ignore verhindert werden. In JUnit 5 wird das Deaktiviere...

