JUnit-Lernprogramm: Einrichten, Schreiben und Ausführen von Java-Komponententests

Verstehen Sie die Grundlagen und skalieren Sie Ihre Unit-Test-Praxis wie ein Profi mit diesem Tutorial.

Möchten Sie die Grundlagen überspringen und sehen, wie Sie automatisieren können? Unit-Test-Generierung mit KI erweitert in <0 Minuten von 60 auf über 5 % Codeabdeckung gehen? Schauen Sie sich Jtest an >>

Was ist Unit Testing?

Lassen Sie uns zunächst ein wenig darüber sprechen was Unit-Tests sind und warum es im Allgemeinen wichtig ist.

Unit-Tests sind eine Form von White-Box-Tests, bei denen Testfälle auf der internen Struktur basieren. Der Tester wählt Eingaben aus, um bestimmte Pfade durch den Code auszuführen, und konfiguriert Zusicherungen, die die Ausgabe validieren. Der Zweck von Komponententests besteht darin, die einzelnen Komponenten oder Teile von Methoden/Klassen zu untersuchen, um die Funktionalität zu überprüfen und sicherzustellen, dass das Verhalten wie erwartet ist.

Der genaue Umfang einer „Einheit“ bleibt oft der Interpretation überlassen, aber eine gute Faustregel besteht darin, eine Einheit als die geringste Menge an Code zu definieren, die zum Ausführen einer eigenständigen Aufgabe erforderlich ist, beispielsweise einer einzelnen Methode oder Klasse.

Es gibt einen guten Grund, warum wir den Umfang beim Komponententest einschränken: Wenn wir einen Test erstellen, der einen breiten Teil eines Projekts validiert, verlagern wir den Fokus von der Funktionalität einer einzelnen Methode auf die Interaktionen zwischen verschiedenen Teilen des Codes. Wenn der Test fehlschlägt, wissen wir nicht, warum er fehlgeschlagen ist. Wir fragen uns, ob der Fehlerpunkt in der Methode lag, an der wir interessiert waren, oder in den Abhängigkeiten, die mit dieser Methode verbunden sind.

Was ist JUnit?

JUnit ist das beliebteste Framework für Java-Komponententests. Ein Open-Source-Framework, das zum Schreiben und Ausführen wiederholbarer automatisierter Tests verwendet wird.

Wie bei allem anderen hat sich das JUnit-Testframework im Laufe der Zeit weiterentwickelt. JUnit 4.0 wurde 2006 veröffentlicht und 5.0 wurde 2017 veröffentlicht. Zum Zeitpunkt der Erstellung dieses Artikels ist die neueste Version 5.12.1. JUnit 5.x hat viele der früheren Einschränkungen von JUnit behoben und ist zum robustesten Framework für Java-Komponententests geworden.

Dieser Blogbeitrag behandelt die Verwendung von JUnit 4 und 5.

So richten Sie JUnit-Tests ein

Tauchen wir also gleich ein. Hier sind die Schritte zum Einrichten von JUnit.

Bei den gebräuchlicheren IDEs wie Eclipse und IntelliJ ist die JUnit-Testing-Integration bereits standardmäßig installiert. Wenn Sie keine IDE verwenden und sich vielleicht nur auf ein Build-System wie Maven oder Gradle verlassen, wird die Installation von JUnit 4/5 über die Datei pom.xml bzw. build.gradle abgewickelt.

Es ist wichtig zu beachten, dass JUnit 5 in 3 Module aufgeteilt wurde, von denen eines ein Vintage-Modul ist, das Anmerkungen/Syntax von JUnit 4 und 3 unterstützt. Die Nutzung von JUnit 3 ist zu diesem Zeitpunkt sehr gering und wird normalerweise nur in viel älteren Projekten gesehen.

Einheit 5

Aufgrund des modularen Aufbaus von JUnit 5 wird eine Stückliste (POM) zum Importieren aller JUnit-Module und -Abhängigkeiten verwendet. Werden nur bestimmte Module benötigt, können stattdessen einzelne Gruppen oder Artefakte angegeben werden.

Fügen Sie pom.xml Folgendes hinzu, um Javen JUnit 5 zu Maven hinzuzufügen:

<dependency> <groupId>org.junit</groupId> <artifactId>junit-bom</artifactId> <version>5.12.1</version> <scope>test</scope> </dependency>

Fügen Sie für Gradle Folgendes zur Datei build.gradle hinzu:

apply plugin: 'java'

dependencies {
implementation 'org.junit:junit-bom:5.12.1'
}

Einheit 4

Um JUnit 4 zu Maven hinzuzufügen, fügen Sie Folgendes zu pom.xml hinzu.

<dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.13.2</version> <scope>test</scope> </dependency>

Fügen Sie für gradle Folgendes zur build.gradle hinzu:

apply plugin: 'java'

dependencies {
testCompile 'junit:junit:4.13.2'
}

Wenn Sie JUnit für JUnit-Tests manuell zum Klassenpfad hinzufügen müssen, müssen Sie die JAR-Rohdateien direkt referenzieren, obwohl dies normalerweise nicht erforderlich ist. Sowohl JUnit 4 als auch JUnit 5 bieten die JAR-Datei zum direkten Download an. Für JUnit 5 müssen Sie eine Fat-JAR-Datei (auch bekannt als Uber-JAR) wie beschrieben herunterladen. hier.

Unit-Tests schreiben: Die Anatomie einer Einheit

Nachdem wir nun ein wenig über das JUnit-Setup gesprochen haben, wollen wir mit der eigentlichen Konstruktion und Ausführung dieser Tests fortfahren. Um die Erstellung von JUnits am besten zu veranschaulichen, beginnen wir mit etwas Grundlegendem. Im folgenden JUnit-Testbeispiel haben wir eine einfache Methode (links), der Fahrenheit in Celsius umwandelt, und einen JUnit-Test (Recht) geschrieben, um unsere Methode zu testen. Ich habe die wichtigsten Teile des JUnit-Tests nummeriert und werde jeden Teil unten im Detail besprechen.

Teile 1 und 2

Dies sind Importe für die JUnit-Klassen und -Pakete, die vom Komponententest verwendet werden. Die Importe können als einzelne Klassen angegeben werden, werden aber üblicherweise als ganze Pakete mit Sternchen angegeben. So oder so funktioniert – die Granularität der Importe ist eine Frage der Präferenz.

Teil 3

Dies definiert den Start unserer Testklasse. Das Wichtige, was hier zu beachten ist, ist die Namenskonvention, die für die Klasse verwendet wird, nämlich KlassennameTest. Diese Namenskonvention ist nicht erforderlich, aber es ist die gebräuchlichste Art, JUnit-Klassen zu benennen, da der Name den Zweck der Unit-Test-Klasse und die Klasse, die sie testet, prägnant beschreibt.

Teil 4

Hier sehen wir unsere erste JUnit-spezifische Syntax: die Annotation @Test. Anmerkungen sind beim Erstellen von JUnits äußerst wichtig. So identifiziert das JUnit-Framework die wichtigen Teile des Unit-Tests. In unserem Beispiel teilt die Annotation @Test JUnit mit, dass die öffentliche void-Methode, an die sie angehängt ist, als Testfall ausgeführt werden kann.

Es gibt viele andere Anmerkungen, aber einige der häufigsten sind die folgenden.

• @Before identifiziert eine Methode, die vor jeder Testmethode in der Klasse ausgeführt werden sollte. Es wird normalerweise verwendet, um den Status zu aktualisieren oder zurückzusetzen, der für die ordnungsgemäße Ausführung der Testmethoden erforderlich ist.
• @After identifiziert eine Methode, die nach jeder Testmethode in der Klasse ausgeführt werden sollte. Es kann verwendet werden, um Variablen zurückzusetzen, temporäre Dateien zu löschen und so weiter.
• @Ignore gibt an, dass eine Testmethode nicht ausgeführt werden soll.
• @BeforeClass identifiziert eine Methode, die einmal ausgeführt werden sollte, bevor Testmethoden ausgeführt werden.
• @AfterClass identifiziert eine Methode, die einmal ausgeführt werden sollte, nachdem alle Testmethoden ausgeführt wurden.

Teil 5

Beachten Sie auch hier die Namenskonvention testMethodenname, Wobei Methodenname ist der Name der Methode, die in der zu testenden Klasse getestet wird.

Teil 6

Im Gegeben Abschnitt des Tests konstruieren wir eine neue Instanz der zu testenden Klasse und initialisieren sie entsprechend. Dies ist notwendig, da die Testmethode die zu testende Methode aufrufen muss, um sie zu testen. In unserem Beispiel ist neben der Instanziierung der Klasse keine weitere Initialisierung erforderlich, aber in vielen Fällen müssen möglicherweise zusätzliche Einstellungen vorgenommen werden, z. B. das Initialisieren von Objekten zur Übergabe an den Konstruktor oder das Aufrufen von Methoden, die den Zustand der zu testenden Klasse konfigurieren.

Teil 7

Die Beim Der Abschnitt des Tests umfasst das Initialisieren von Variablen, die übergeben werden müssen, wenn die zu testende Methode aufgerufen wird, und dann das Aufrufen der Testmethode (Teil 8). Den Variablen sollten aussagekräftige Werte gegeben werden, die bewirken, dass der Test die Teile der Testmethode ausführt, die uns wichtig sind. Beachten Sie, dass eine Variable, die ein Objekt ist, instanziiert oder verspottet werden kann.

Teil 8

Wenn die zu testende Methode einen Wert zurückgibt, sollte dieser in einer Variablen erfasst werden, damit sein Wert geltend gemacht werden kann.

Teil 9

Komponententests sind nur dann sinnvoll, wenn sie Behauptungen enthalten, die bestätigen, dass die getestete Methode den richtigen Wert zurückgibt und/oder den Zustand anderer Objekte wie erwartet anpasst. Ohne Zusicherungen haben Sie keine Verifizierung, und Ihr Test ist bestenfalls ein Rauchtest, der nur dann Feedback gibt, wenn eine Ausnahme ausgelöst wird.

Die JUnit-Assertionsmethoden, die in JUnit 5 in der Klasse org.junit.jupiter.api.Assertions und in JUnit 4 in der Klasse org.junit.Assert enthalten sind, werden häufig verwendet, um den Pass/Fail-Status von Testfällen zu bestimmen. Nur fehlgeschlagene Zusicherungen werden vom JUnit-Framework gemeldet. Wie bei Annotationen gibt es viele Behauptungsmöglichkeiten.

In unserem obigen Beispiel-JUnit verwenden wir die Methode assertEquals (erwartet, aktuell, Delta). Das erste Argument ist:

• Die erwartetes Ergebnis, die der Testautor definiert.
• Die tatsächliche Leistung, was der Rückgabewert der aufgerufenen Methode ist
• Die Delta, die eine akzeptable Abweichung zwischen erwarteten und tatsächlichen Werten zulässt. Dieses Delta ist spezifisch für die Tatsache, dass wir den Wert eines Double-Typs validieren.

So führen Sie eine JUnit aus

Wähle dein eigenes Abenteuer! Hier sehen wir uns drei Möglichkeiten zum Ausführen von JUnits an: direkt über die Befehlszeile, über die IDE (Eclipse und IntelliJ) und mithilfe von Build-Systemen (Maven und Gradle).

So führen Sie ein JUnit von der Befehlszeile aus

Um ein JUnit direkt von der Kommandozeile aus auszuführen, benötigen Sie ein paar Dinge:

• JDK auf Ihrem Weg
• Die JUnit-JAR-Datei(en)
• Die Testfälle

Der Befehl lautet wie folgt. Dieses Beispiel gilt für JUnit 4.

java -cp /path/to/junit.jar org.junit.runner.JUnitCore <test class name>

Hinweis: Das Ausführen eines Tests über die Befehlszeile erfolgt am häufigsten über einen CI/CD-Prozess, der in einem Buildsystem wie Jenkins oder Azure DevOps ausgeführt wird.

So führen Sie eine JUnit über die IDE aus

Eclipse

Suchen Sie im Paket-Explorer Ihren JUnit-Test. Klicken Sie mit der rechten Maustaste und wählen Sie Ausführen als > JUnit-Test. Dadurch werden Ihre Test- und Berichtsergebnisse in der JUnit Eclipse-Ansicht ausgeführt.

IntelliJ

Das Ausführen eines Tests in IntelliJ ähnelt Eclipse. Suchen Sie im Projektfenster Ihren Test, klicken Sie mit der rechten Maustaste, und wählen Sie „Testname“ ausführen aus. Wie bei Eclipse öffnet sich ein JUnit-Fenster mit den Ergebnissen des Tests.

So führen Sie eine JUnit mit Build-Systemen aus

Maven

Maven hat das Ausführen von Unit-Tests vereinfacht. Stellen Sie sicher, dass Sie sich in Ihrer Befehlszeile am richtigen Speicherort befinden und das Projekt pom.xml richtig konfiguriert ist. Dann können Sie Folgendes ausführen, um Ihre JUnits auszuführen.

So führen Sie die gesamte Testsuite aus:

mvn test

So führen Sie einen oder mehrere einzelne/spezifische Tests durch:

mvn -Dtest=TestName test

Gradle

Gradle hat wie Maven das Ausführen von Tests vereinfacht.

So führen Sie die gesamte Testsuite aus:

gradlew test

So führen Sie einen oder mehrere einzelne/spezifische Tests durch:

gradlew -Dtest.single=testName test

Hinweis: Maven und Gradle sind ihre eigenen Bestien. Was hier gezeigt wird, ist minimal, um die Grundlagen abzudecken. Schauen Sie sich ihre Dokumentation an, wenn Sie mehr erfahren möchten.

Fortsetzung des Unit-Tests

Unser Beispiel durchlief einen einfachen Unit-Test, und das ist natürlich nur der Anfang von Unit-Tests. Komplexere zu testende Methoden rufen möglicherweise Methoden in abhängigen Klassen auf oder verbinden sich mit externen Systemen wie einer Datenbank. In solchen Fällen kann es sinnvoll sein, den Code durch Mocking zu isolieren.

Mocking hilft dabei, Codeeinheiten zu isolieren, sodass sich unsere Komponententests nur auf die spezifische zu testende Klasse/Methode konzentrieren können. Das am häufigsten zum Mocking in JUnit-Tests verwendete Framework ist Mockito.

Um mehr über das Spotten zu erfahren, lesen Sie den Beitrag meines Kollegen: So automatisieren Sie einen Java-Komponententest, einschließlich Verspottungen und Behauptungen.

Wenn Unit-Tests so wichtig sind, warum werden sie dann nicht von allen konsequent durchgeführt? Trotz ihrer Bedeutung sind Unit-Tests nicht immer einfach zu implementieren und zu pflegen. Sie erfordern fundiertes Entwicklungswissen und kontinuierlichen Aufwand, um die Test-Suites aktuell zu halten. Daher werden Unit-Tests oft vernachlässigt – bis es zu Regressionen kommt.

Aber so muss es nicht sein.

Beschleunigen Sie JUnit-Tests mit KI

Hier ist Parasoft Test kommt ins Spiel. Sein KI-gestützter Unit-Test-Assistent wurde entwickelt, um die Hürden beim Schreiben und Pflegen von Unit-Tests zu beseitigen. Mit nur wenigen Klicks können Teams, die bei 0 % beginnen, sofort loslegen. Codeabdeckung kann automatisch robuste Testsuiten generieren, die 60 % oder mehr ihres Java-Codes abdecken. Als eine Finanzdienstleistungsunternehmen bemerkte: „Seit wir Parasoft Jtest implementiert haben, konnten wir den Zeitaufwand für die Erstellung und Wartung von Unit-Tests erfolgreich um mehr als 50 % reduzieren.“

So kann Ihr Team Ihre Testpraxis skalieren.

• Automatische Generierung von JUnit-Testfällen für zuvor nicht entdeckten Code mithilfe der intelligenten Massentesterstellung.
• Mocks und Stubs generieren um Abhängigkeiten zu isolieren und Ihre Tests zu fokussieren. Dies spart Zeit und macht das manuelle Schreiben von Mocking-Logik überflüssig.
• Anpassen und Erweitern von Tests mit Ein-Klick-Aktionen zum Hinzufügen von Behauptungen, Parametrisieren von Testfällen und Verbessern der Wartbarkeit.
• Ziel des geänderten Codes direkt in der IDE und schließen Sie Lücken in der Testabdeckung schneller mit den KI-generierten Vorschlägen des Unit Test Assistant.
• Schützen Sie Ihre Daten mit der proprietären KI von Parasoft, die vor Ort ausgeführt werden kann – kein Code oder Daten verlässt Ihre Umgebung.
• Beschleunigen Sie die Testausführung mit eingebauten Test Impact Analysis und Live-Unit-Tests, das nur die Tests identifiziert und ausführt, die zur Validierung Ihrer letzten Codeänderungen erforderlich sind.

Wenn Ihnen das Schreiben und Warten von JUnit-Tests wie eine lästige Pflicht vorkommt, ist es Zeit, Ihren Ansatz zu modernisieren. KI-gestützte Testlösungen wie diese können die Testerstellung von einem Engpass in einen strategischen Vorteil verwandeln – und Ihnen mehr Zeit für die Entwicklung großartiger Software geben.