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

Möchten Sie die Grundlagen überspringen und sehen, wie Sie die Generierung von Komponententests automatisieren, um eine Codeabdeckung von über 60 % in <5 Minuten zu erreichen? 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 „Unit“ wird oft der Interpretation überlassen, aber eine nette Faustregel ist, eine Unit als die geringste Menge an Code zu definieren, die benötigt wird, um eine eigenständige Aufgabe auszuführen, z. B. eine einzelne 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.9.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 ein BOM verwendet, um alle JUnit-Module und -Abhängigkeiten zu importieren. Wenn nur bestimmte Module benötigt werden, 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.9.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.9.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</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'
}

Wenn Sie JUnit manuell zum Klassenpfad für JUnit-Tests hinzufügen müssen, müssen Sie direkt auf die rohen JAR-Dateien verweisen, obwohl dies normalerweise nicht erforderlich ist. JUnit 4 stellt das JAR zum direkten Download zur Verfügung. Junit 5 (während ich dies schreibe) hat derzeit keine vorgefertigte JAR-Datei, aber Sie können den Code einfach kompilieren und die JAR-Dateien generieren. JUnit 4 stellt das JAR zum direkten Download zur Verfügung.

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

In den 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

Dieses Wann 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:

• Dieses erwartetes Ergebnis, die der Testautor definiert.
• Dieses tatsächliche Leistung, was der Rückgabewert der aufgerufenen Methode ist
• Dieses 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 erst der Anfang des Unit-Tests. Komplexere Methoden, die getestet werden müssen, können Methoden in abhängigen Klassen aufrufen oder sich mit externen Systemen wie einer Datenbank verbinden. In solchen Fällen kann es wünschenswert sein, den Code durchzuisolieren Verspottung.

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 macht das dann nicht jeder konsequent? Nun, Unit-Tests sind nicht einfach zu implementieren. Es erfordert auch eine Menge Entwicklungsfähigkeiten. Entwickler neigen dazu, Unit-Tests nicht sehr zu genießen. Die Wartung von Testsuiten erfordert Engagement und Zeit.

Aber die Vorteile von Unit-Tests liegen auf der Hand.

Es muss sichergestellt werden, dass zuvor geschriebener Code weiterhin funktioniert, wenn sich der Code weiterentwickelt und der Anwendung neue Funktionen hinzugefügt werden. Komponententests werden im Allgemeinen schnell ausgeführt und sind effektiv beim Erfassen von Regressionen, die in den Code eingeführt wurden. Unit-Tests sind eine allgemeine Anforderung, um sicherzustellen, dass Anwendungen weiterhin wie vorgesehen funktionieren. Es ist eine schnelle Möglichkeit, Feedback zu Codeänderungen zu erhalten, bevor sie in die Anwendung integriert werden.

Daher ist es hilfreich, leistungsstarke Unit-Test-Tools wie z Parasoft Jtest Das kann viele der Herausforderungen im Zusammenhang mit JUnit-Tests lösen und Entwicklern wertvolle Zeit sparen.

KI-betrieben von Parasoft Jtest Unit-Test-Assistent ermöglicht es Benutzern, mit einer einzigen Aktion schnell Testsuiten zu generieren, die 60 % oder mehr ihres Anwendungscodes abdecken. Wenn die Testerstellung an die Grenzen dessen stößt, was vollständig automatisiert werden kann, bietet der Unit-Test-Assistent Workflows und Empfehlungen, die Benutzern helfen, Tests effizienter manuell zu erstellen.

Darüber hinaus beschleunigt das Testauswirkungsanalysemodul die Ausführungszeit von Einheitentests innerhalb von CI/CD-Prozessen oder der IDE, indem es nur die Teilmenge der Einheitentestsuite identifiziert und ausführt, die zur Validierung kürzlicher Codeänderungen erforderlich ist.