Verwenden von JUnit 5 mit Gradle

1. Übersicht

In diesem Tutorial werden wir Tests auf der neuen JUnit 5-Plattform mit dem Gradle-Build-Tool ausführen.

Wir werden ein Projekt konfigurieren, das sowohl die alte als auch die neue Version unterstützt.

Weitere Informationen zur neuen Version finden Sie in A Guide to JUnit 5. Oder die Einführung in Gradle, um detaillierte Informationen zum Build-Tool zu erhalten.

2. Gradle-Setup

Zunächst überprüfen wir, ob Version 4.6 oder höher des Build-Tools installiert ist, da dies die früheste Version ist, die mit JUnit 5 funktioniert.

Am einfachsten ist es, einfach den Befehl gradle -v auszuführen :

$> gradle -v ------------------------------------------------------------ Gradle 4.10.2 ------------------------------------------------------------

Bei Bedarf können wir die Installationsschritte ausführen, um die richtige Version zu erhalten.

Sobald wir alles installiert haben, müssen wir Gradle mithilfe der Datei build.gradle konfigurieren .

Wir können damit beginnen, die Unit-Test-Plattform für das Build-Tool bereitzustellen:

test { useJUnitPlatform() } 

Nachdem wir die Plattform angegeben haben, müssen wir die JUnit-Abhängigkeiten bereitstellen. Hier sehen wir einen bemerkenswerten Unterschied zwischen JUnit 5 und früheren Versionen.

In früheren Versionen brauchten wir nur eine Abhängigkeit. In JUnit 5 ist die API jedoch von der Laufzeit getrennt, was zwei Abhängigkeiten bedeutet.

Die API manifestiert sich mit junit-jupiter-api . Die Laufzeit ist Junit-Jupiter-Engine für JUnit 5 und Junit-Vintage-Engine für JUnit 3 oder 4.

Wir werden diese beiden in testImplementation bzw. timeRuntimeOnly bereitstellen :

dependencies { testImplementation 'org.junit.jupiter:junit-jupiter-api:5.3.1' testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.3.1' }

3. Tests erstellen

Schreiben wir unseren ersten Test. Es sieht genauso aus wie in früheren Versionen:

@Test public void testAdd() { assertEquals(42, Integer.sum(19, 23)); }

Jetzt können wir den Test ausführen, indem wir den Befehl gradle clean test ausführen .

Um zu überprüfen, ob wir JUnit 5 verwenden, können wir uns die Importe ansehen. Die Importe für @Test und assertEquals sollten ein Paket haben, das mit org.junit.jupiter.api beginnt:

import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals;

Im letzten Beispiel haben wir einen Test mit 'alten' Funktionen erstellt, der seit Jahren funktioniert. Wir werden jetzt ein weiteres Beispiel erstellen, das einige der neuen Funktionen in JUnit 5 verwendet:

@Test public void testDivide() { assertThrows(ArithmeticException.class, () -> { Integer.divideUnsigned(42, 0); }); }

assertThrows ist eine neue Zusicherung in JUnit5, die den alten Stil von @Test ersetzt (erwartet = ArithmeticException.class).

4. Konfigurieren von JUnit 5-Tests mit Gradle

Als nächstes werden wir eine tiefere Integration zwischen Gradle und JUnit5 untersuchen.

Nehmen wir an, wir haben zwei Arten von Tests in unserer Suite: Langzeit- und Kurzzeittests. Wir könnten die Annotation JUnit 5 @Tag verwenden :

public class CalculatorJUnit5Test { @Tag("slow") @Test public void testAddMaxInteger() { assertEquals(2147483646, Integer.sum(2147183646, 300000)); } @Tag("fast") @Test public void testDivide() { assertThrows(ArithmeticException.class, () -> { Integer.divideUnsigned(42, 0); }); } }

Dann teilen wir dem Build-Tool mit, welche ausgeführt werden sollen. In unserem Fall führen wir einfach die kurzen (schnellen) Tests aus:

test { useJUnitPlatform { includeTags 'fast' excludeTags 'slow' } }

5. Aktivieren der Unterstützung für alte Versionen

Mit der neuen Jupiter-Engine können jetzt noch JUnit 3- und 4-Tests erstellt werden. Darüber hinaus können wir sie mit der neuen Version im selben Projekt mischen, beispielsweise in einem Migrationsszenario.

Zu Beginn fügen wir der vorhandenen Build-Konfiguration einige Abhängigkeiten hinzu:

testCompileOnly 'junit:junit:4.12' testRuntimeOnly 'org.junit.vintage:junit-vintage-engine:5.3.1'

Beachten Sie, dass unser Projekt jetzt sowohl eine Junit-Jupiter-Engine als auch eine Junit-Vintage-Engine hat.

Jetzt erstellen wir eine neue Klasse und kopieren die zuvor erstellte testDivide- Methode. Dann fügen wir die Importe für @Test und assertEquals hinzu . Diesmal stellen wir jedoch sicher, dass wir die alten Pakete der Version 4 verwenden, ab denen org.junit:

import static org.junit.Assert.assertEquals; import org.junit.Test; public class CalculatorJUnit4Test { @Test public void testAdd() { assertEquals(42, Integer.sum(19, 23)); } }

6. Fazit

In diesem Tutorial haben wir Gradle in JUnit 5 integriert. Darüber hinaus haben wir die Unterstützung für die Versionen 3 und 4 hinzugefügt.

Wir haben gesehen, dass das Build-Tool die alte und die neue Version hervorragend unterstützt. Daher können wir die neuen Funktionen in einem vorhandenen Projekt verwenden, ohne alle vorhandenen Tests ändern zu müssen.

Das vollständige Codebeispiel ist im GitHub-Projekt verfügbar. Fühlen Sie sich frei, es als Ausgangspunkt für Ihr eigenes Projekt zu verwenden.