Unit-Tests in Java schreiben

Tests sind eine wichtige Best Practice bei der Softwareentwicklung. Unit-Tests sind eine von zahlreichen Methoden, mit denen wir sicherstellen können, dass unser Code funktioniert und optimal arbeitet. Als Entwickler können wir Unit-Tests schreiben, um einzelne Komponenten (Units) des Anwendungscodes zu überprüfen, etwa eine bestimmte Methode. Die Idee ist, für jeden Codeabschnitt einen oder mehrere Unit-Tests zu schreiben und sie bei jeder Änderung auszuführen, damit Fehler so früh wie möglich erkannt werden. Für neuen Code sollten Tests hinzugefügt werden, während (oder sogar bevor) der Code geschrieben wird. Bei vorhandenem Code sollten Tests, falls es noch keine gibt, ergänzt werden, um einen Großteil – wenn nicht alle – Ausführungspfade der Anwendungslogik abzudecken.

Unit-Tests sollen alle externen Abhängigkeiten ausschließen und bestätigen, dass sich ein bestimmter Codeabschnitt in verschiedenen Situationen wie erwartet verhält. Dazu kann eine Methode wiederholt mit jeweils neuen Parametern aufgerufen und geprüft werden, ob sie den richtigen Wert zurückgibt, eine Ausnahme auslöst oder eine bestimmte Aufgabe erledigt.

Viele Java-Entwickler verwenden eines der verfügbaren Unit-Test-Frameworks: JUnit. In diesem Beitrag erfahren Sie, wie Sie JUnit 5 installieren und verwenden, um Unit-Tests für Java-Code zu schreiben. Zum Schreiben der Tests verwenden wir die integrierte Entwicklungsumgebung (IDE) VSCode und führen sie mit Java 11 und Maven aus. Tools wie Eclipse und IntelliJ funktionieren jedoch ähnlich, sodass Sie den Schritten folgen können.

Eine größere Auswahl an Tools für die Überprüfung Ihres Java-Codes finden Sie in unserem Beitrag zu Tools für Java-Code-Reviews oder in unserem Beitrag zur Java-Sicherheit, der Ihnen weitere Grundlagen vermittelt.

So schreiben Sie Ihren ersten Unit-Test in Java

In diesem Abschnitt installieren wir das JUnit-Framework und schreiben einige Unit-Tests. Später führen wir die Tests für dieses Beispiel-Codeprojekt aus. Das Projekt ist bereits mit dem Anwendungscode und einer Vorlage für eine Testklasse vorkonfiguriert, die alles enthält, was wir brauchen, um mit dem Hinzufügen von Tests zu beginnen.

Sehen wir uns zunächst den Beispielcode an, bevor wir mit dem Schreiben unserer Tests beginnen.

1package com.snyk.unittestdemo;
2
3public class App 
4{
5    public static void main( String[] args )
6    {
7        try {
8            System.out.println(generateUpdateUserFirstNameStatement("John", "abcdef1234567"));
9        }
10        catch (Error e){
11            e.printStackTrace();
12        }
13    }
14
15    public static String generateUpdateUserFirstNameStatement(String firstName, String userId) throws Error{
16        if(userId.contains(";") || firstName.contains(";")){
17            throw new Error("parameters may contain SQL injection");
18        }
19        return "UPDATE TABLE user SET first_name = '" + firstName + "' WHERE user_id = '" + userId +"';" ;
20    }
21
22}

Unsere Anwendung verfügt über eine main-Methode, die die Methode generateUpdateUserFirstNameStatement aufruft und die Ausgabe ausgibt. Wenn beim Aufruf der Methode generateUpdateUserFirstNameStatement ein Fehler auftritt, fängt die Anwendung die Ausnahme ab und gibt den Stacktrace aus.

Die Methode generateUpdateUserFirstNameStatement ist eine einfache Methode, die zwei String-Parameter entgegennimmt und daraus eine SQL-UPDATE-Anweisung erstellt. Der Code löst einen Fehler aus, wenn einer der Parameter ein Semikolon enthält, da die Eingabe wahrscheinlich eine SQL-Injection enthält.

Diese Methode eignet sich hervorragend als Beispiel für Unit-Tests, da wir ihre Funktionsweise in zwei Szenarien überprüfen möchten. Übergeben wir zunächst zwei gewöhnliche Strings als Parameter, erwarten wir als Ergebnis einen String mit der SQL-Anweisung. Geben wir anschließend als zweiten Parameter einen String mit einer SQL-Injection an, erwarten wir, dass die Methode einen Fehler auslöst. Beide Fälle können wir mit einem Unit-Test überprüfen.

Zu Beginn müssen wir einige Maven-Pakete installieren, darunter das maven-surefire-plugin, das die JUnit-Bibliothek enthält. Außerdem müssen wir Maven mitteilen, dass unsere Anwendung beim Ausführen von Tests von JUnit abhängt.

Öffnen Sie die bereitgestellte Datei pom.xml und fügen Sie den folgenden Abhängigkeitscode im entsprechenden Abschnitt in Zeile 21 hinzu.

1<dependency>
2  <groupId>junit</groupId>
3  <artifactId>junit</artifactId>
4  <version>4.11</version>
5  <scope>test</scope>
6</dependency>

Speichern Sie die Datei anschließend.

Nun können wir Maven zum Installieren der Pakete verwenden. Öffnen Sie dazu in VSCode links unten das Menü Maven, klicken Sie mit der rechten Maustaste auf das Projekt und wählen Sie install. Wenn Sie eine andere IDE verwenden, kann dieser Vorgang anders aussehen.

Wenn Sie nicht sicher sind, wie das in Ihrer IDE funktioniert, können Sie die Abhängigkeiten jederzeit über die Befehlszeile installieren. Wechseln Sie in einem Terminal in das Stammverzeichnis Ihres Projekts und führen Sie den folgenden Maven-Befehl aus, um die Abhängigkeiten zu installieren.

Hinweis: Wenn Maven noch nicht auf Ihrem Rechner installiert ist, befolgen Sie vor der Ausführung dieses Befehls die Installationsanleitung.

1mvn install -f pom.xml

Nach Abschluss hat Maven die in unserer Datei pom.xml file angegebenen Plugins installiert, darunter die JUnit-Bibliothek. Beim Ausführen von Tests weiß Maven, dass JUnit verwendet werden soll, da wir es in der Konfiguration mit <scope>test</scope> als Testabhängigkeit definiert haben.

Wie die obige Ausgabe zeigt, werden am Ende des Installationsvorgangs Informationen zu unseren Tests angezeigt. Da derzeit jedoch keine Tests konfiguriert sind, wurden 0 Tests ausgeführt. Ändern wir das, indem wir unserer Anwendung zwei Unit-Tests hinzufügen.

Öffnen Sie zunächst die Datei src/test/java/com/snyk/unittestdemo/AppTest.java, die Maven zum Ausführen unserer Tests verwendet. Zuerst müssen wir die benötigten JUnit-Pakete importieren. Fügen Sie die folgenden beiden Import-Anweisungen am Anfang der Datei ein:

1import org.junit.Test;
2
3import static org.junit.Assert.assertTrue;

Mit dem ersten Import erhalten wir Zugriff auf die JUnit-Testannotation, mit der wir unsere Methoden als Tests definieren können. Der zweite Import betrifft die von JUnit bereitgestellte Methode assertTrue. Mit dieser Methode prüfen wir, ob eine Bedingung wahr ist. Ist das der Fall, besteht der Test. Andernfalls schlägt er fehl.

Fügen wir unseren ersten Test hinzu. Er überprüft, ob unsere Methode generateUpdateUserFirstNameStatement bei zwei gewöhnlichen Strings das richtige Ergebnis zurückgibt. Fügen Sie dazu der Klasse AppTest die folgende Methode hinzu.

1@Test
2public void shouldGenerateUpdateStatement()
3{
4    String actual = App.generateUpdateUserFirstNameStatement("John", "abcdef1234567");
5    String expected = "UPDATE TABLE user SET first_name = 'John' WHERE user_id = 'abcdef1234567';";
6    assertTrue( actual.equals(expected) );
7}

Mit der Annotation @Test haben wir die Methode als Test definiert. Anschließend haben wir die importierte Methode assertTrue verwendet, um die Ausgabe unserer Methode generateUpdateUserFirstNameStatement zu überprüfen. Wir haben die beiden Strings John und abcdef1234567 übergeben und möchten prüfen, ob die Funktion den erwarteten String zurückgibt. Wenn unsere Methode korrekt funktioniert, sollte dieser Test bestehen.

Speichern Sie die Datei und führen Sie den Test aus, um zu überprüfen, ob er besteht. In VSCode können Sie mit der rechten Maustaste auf das Maven-Projekt klicken und test auswählen.

Sie können diesen Befehl jederzeit im Terminal ausführen. Öffnen Sie dazu das Terminal, wechseln Sie in den Projektordner und führen Sie den folgenden Befehl aus.

1mvn test -f pom.xml

Mit diesem Befehl weisen Sie Maven an, die Anwendung zu erstellen und die Tests auszuführen. In der Testausgabe sollte nun stehen, dass ein Test ausgeführt wurde und keine Fehler aufgetreten sind.

Ändern wir nun die Methode generateUpdateUserFirstNameStatement leicht, indem wir die von der Funktion zurückgegebene UPDATE-Anweisung anpassen. Führen Sie die Tests erneut aus, um zu sehen, wie Maven einen Fehler anzeigt.

Die Ausgabe ändert sich nun und zeigt an, dass ein Test fehlgeschlagen ist. Unter der Überschrift Results: sehen Sie die Anzahl und Art der Fehler. In diesem Fall werden in den Ergebnissen unsere Testmethode generateUpdateUserFirstNameStatement und die Zeilennummer des Fehlers (Zeile 14) angegeben. Denken Sie daran, die Änderungen rückgängig zu machen, durch die die Funktion beeinträchtigt wurde.

Wir können auch überprüfen, ob unsere Funktion wie vorgesehen einen Fehler auslöst. Dafür verwenden wir einen etwas anderen Ansatz als die Methode assertTrue. Fügen Sie zunächst die folgende Testmethode zur Testklasse hinzu.

1@Test(expected = Error.class)
2public void shouldThrowErrorForSQLInjection()
3{
4    App.generateUpdateUserFirstNameStatement("John", "abcdef1234567; DROP TABLE user;");
5}

Hier haben wir die Annotation @Test verwendet, um einen erwarteten Wert anzugeben. Wir erwarten, dass unsere Methode eine Instanz der Klasse Error auslöst, da wir sie so programmiert haben, dass sie eine SQL-Injection in einem der beiden Parameter behandelt. Nun können wir die Tests ausführen und überprüfen, ob sie bestehen.

Wir haben erfolgreich unsere ersten Java-Unit-Tests mit JUnit implementiert. Damit können wir sicherstellen, dass unser Code wie erwartet funktioniert und die richtigen Ergebnisse liefert. Ist das nicht der Fall, schlägt unser Test fehl.

Es ist unerlässlich, unsere Anwendungen vor Sicherheitslücken zu schützen, etwa vor solchen, die uns bösartigen SQL-Injections aussetzen. Ein Test wie dieser kann verhindern, dass Entwickler diese Sicherheitslücke künftig einführen. Tests stärken unser Vertrauen in den Code und bieten zukünftigen Entwicklern ein Sicherheitsnetz. Hier erfahren Sie mehr über Best Practices für Java-Sicherheit.

Snyk Code ist ein weiteres Tool, das unsichere Programmierpraktiken erkennt, die Entwicklern möglicherweise nicht bewusst sind und für die keine Tests geschrieben wurden. Dazu gehört das Erkennen von Code, der für SQL-Injections anfällig ist, sowie von fest codierten vertraulichen Informationen wie API-Schlüsseln und personenbezogenen Daten.

Der Test legt fest, was die Methode leisten soll. Möchte ein Entwickler die Methode generateUpdateUserFirstNameStatement aktualisieren und macht sie dabei versehentlich kaputt – wie bei unserem zweiten Test –, schlägt der Unit-Test fehl und liefert Informationen zum Fehler. Diese Vorgehensweise bietet eine zusätzliche Schutzebene gegen den Verlust zentraler Funktionen sowie gegen die Freigabe instabiler oder gefährlicher Änderungen in einer Produktionsanwendung.

Fazit

Wie wir in diesem Tutorial erfahren haben, sind Unit-Tests eine einfache Möglichkeit, sicherzustellen, dass sich unser Code in beliebig vielen Szenarien wie vorgesehen verhält. Außerdem bieten Unit-Tests bei der Zusammenarbeit an Projekten eine zusätzliche Ebene der Fehlertoleranz: Sie verhindern, dass andere Entwickler unseren Code versehentlich beschädigen oder Sicherheitslücken einführen. Unit-Tests sind zwar längst nicht die einzige Methode zum Testen von Anwendungen, sollten aber zum Standardrepertoire aller Entwickler gehören.

Weitere technische Informationen zu Java finden Sie in diesen verwandten Artikeln:

• Serialisierung und Deserialisierung in Java

• Spickzettel zur lokalen Typinferenz in Java

• Best Practices für die Verwaltung von Java-Abhängigkeiten