Erfahren Sie, wie die Continuous Quality Platform von Parasoft dabei hilft, Testumgebungen zu steuern und zu verwalten, um zuverlässig hochwertige Software zu liefern. Für Demo registrieren >>

BLOG

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

JUnit-Lernprogramm: Einrichten, Schreiben und Ausführen von Java-Komponententests Lesezeit: 7 Minuten
Heute kehren wir mit einem der kürzeren (aber nicht weniger nützlichen!) JUnit-Tutorials zum Einrichten, Schreiben und Ausführen Ihrer JUnit-Tests zu den Grundlagen des Komponententests zurück. Was ist eine JUnit und wie fangen Sie an?

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

Was ist Unit Testing?

Aber bevor wir zu sehr auf JUnits eingehen, lassen Sie uns ein wenig darüber sprechen Was ist Unit-Tests? und Regressionstests und warum sie im Allgemeinen wichtig sind. Wir werden im weiteren Verlauf auf einige gute Beispiele eingehen.

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 zu erkunden, und bestimmt die entsprechende Ausgabe. Der Zweck von Unit-Tests besteht darin, die einzelnen Komponenten oder Teile von Methoden / Klassen zu untersuchen, um die Funktionalität zu überprüfen und sicherzustellen, dass das Verhalten den Erwartungen entspricht.

Der genaue Umfang einer „Einheit“ wird oft der Interpretation überlassen, aber eine gute Faustregel ist, dass eine Einheit die geringste Menge an Code enthält, die eine eigenständige Aufgabe ausführt (z. B. eine einzelne Methode oder Klasse). Es gibt einen guten Grund, warum wir den Umfang beim Testen von Einheiten einschränken. Wenn wir einen Test erstellen, der mehrere Aspekte eines Projekts enthält, haben wir den Fokus von der Funktionalität einer einzelnen Methode auf die Interaktion zwischen verschiedenen Teilen des Codes verlagert. Wenn der Test fehlschlägt, wissen wir nicht, warum er fehlgeschlagen ist, und 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.

Regressionstests

Durch Regressionstests, die den Komponententest ergänzen, wird sichergestellt, dass der neueste Fix, die neueste Verbesserung oder der neueste Patch die vorhandenen Funktionen nicht beeinträchtigt, indem die an Ihrem Code vorgenommenen Änderungen getestet werden. Änderungen am Code sind unvermeidlich, egal ob es sich um Änderungen des vorhandenen Codes oder um das Hinzufügen von Paketen für neue Funktionen handelt. Ihr Code wird sich sicherlich ändern. In dieser Änderung liegt die größte Gefahr. Daher sind Regressionstests ein Muss.

JUnit-Grundlagen: Erste Schritte mit JUnit und Verwenden der Automatisierung zum Erstellen von Komponententests

Was ist JUnit?

JUnit ist ein Java-Unit-Test-Framework, das eine der besten Testmethoden für Regressionstests ist. Als Open-Source-Framework werden wiederholbare automatisierte Tests geschrieben und ausgeführt.

Wie bei allem anderen hat sich das JUnit-Testframework im Laufe der Zeit weiterentwickelt. Die wichtigste Änderung, die zu beachten ist, ist die Einführung von Anmerkungen, die mit der Veröffentlichung von JUnit 4 einhergingen und die Organisation und Lesbarkeit von JUnits verbesserten. Der Rest dieses Blog-Beitrags wird aus den Verwendungen von Junit 4 und 5 geschrieben.

So richten Sie JUnit-Tests ein

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

Bei den gängigeren IDEs wie Eclipse und IntelliJ ist die Integration von JUnit-Tests bereits standardmäßig installiert. Wenn Sie keine IDE verwenden und sich möglicherweise ausschließlich auf ein Build-System wie Maven oder Gradle verlassen, erfolgt die Installation von Junit 4/5 über die Datei pom.xml bzw. build.gradle. Es ist wichtig zu beachten, dass Junit 5 in 3 Module aufgeteilt wurde, von denen eines ein Vintage-Modul ist, das Annotation / Syntax von Junit 4 und 3 unterstützt (obwohl die Verwendung von Junit 3 offen gesagt düster ist und normalerweise nur in viel älteren Projekten zu sehen ist).

Einheit 4

Um JUnit 4 zu Ihrem Maven hinzuzufügen, erstellen Sie Folgendes in der Datei pom.xml. Achten Sie auf die Version:

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

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

apply plugin: 'java'

dependencies {
testCompile 'junit:junit:4.12'
}

Einheit 5

Das Hinzufügen von JUnit 5 ist etwas anders. Aufgrund des modularen Aufbaus von JUnit 5 werden alle Aspekte über eine Stückliste importiert. Wenn nur bestimmte Klassen benötigt werden, können 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.2.0</version>
<scope>test</scope>
</dependency>

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

apply plugin: 'java'

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

Wenn Sie den Klassenpfad für JUnit-Tests manuell eingeben müssen, benötigt Java die Raw-JAR-Datei, obwohl dies normalerweise nicht erforderlich ist. Git beherbergt den Code für JUnit. In JUnit 4 kann das Glas direkt heruntergeladen werden. In Junit 5 (während ich dies schreibe) ist die JAR-Datei derzeit nicht vorgefertigt, aber man kann den Code einfach kompilieren und die Jars generieren.

Verbessern Sie Unit-Tests für Java mit Automatisierung: Best Practices für Java-Entwickler
Holen Sie sich das kostenlose E-Book

Unit-Tests schreiben: Die Anatomie einer Einheit

Nachdem wir ein wenig über das Testen und Einrichten von JUnit gesprochen haben, fahren wir mit dem eigentlichen Aufbau und der Ausführung dieser Tests fort. Um die Erstellung von JUnits am besten zu veranschaulichen, möchten wir mit etwas Grundlegendem beginnen. Im folgenden Bild des JUnit-Testbeispiels haben wir eine einfache Methode (links), die Fahrenheit in Celsius umrechnet, und die JUnit (Recht) mit unserer Methode verbunden. Ich habe unsere JUnit nummeriert und werde diese Abschnitte weiter unten ausführlich behandeln.

Abschnitte 1 und 2

Dies sind Importe für die JUnit-Bibliotheken, die zur Nutzung des Testframeworks erforderlich sind. Die importierten Bibliotheken können bis zu einer bestimmten Funktionalität von JUnit angegeben werden, werden jedoch üblicherweise mit Sternchen importiert, um Zugriff auf alle Funktionen zu erhalten.

Abschnitt 3

Dies hat den Beginn unserer Testklasse. Wichtig hierbei ist die Namenskonvention für die Klasse, die auf ClassNameTest folgt.

Abschnitt 4

Hier sehen wir unsere erste JUnit-spezifische Syntax, eine Annotation. Anmerkungen sind beim Erstellen von JUnits äußerst wichtig. Auf diese Weise weiß JUnit, was mit dem Verarbeitungsabschnitt von Code zu tun ist. In unserem Beispielfall haben wir eine @ Test-Annotation, die JUnit mitteilt, dass die öffentliche Void-Methode, an die sie angehängt ist, als Testfall ausgeführt werden kann.

Es gibt viele andere Anmerkungen, aber die häufigsten sind @Before (das eine Anweisung / Vorbedingung vor @Test ausführt, public void), @After (das eine Anweisung nach @Test ausführt, public void, z. B. das Zurücksetzen von Variablen, das Löschen temporärer Dateien, Variablen usw.) und @Ignore (das einige Anweisungen während der Testausführung ignoriert - beachten Sie, dass @BeforeClass und @AfterClass zum Ausführen von Anweisungen vor bzw. nach allen Testfällen verwendet werden, öffentliche statische Leere).

Abschnitt 5:

Das Mitnehmen hier ist wieder Namenskonvention. Beachten Sie die Struktur, testenMethodenname.

Abschnitt 6:

Hier konstruieren wir eine neue Instanz unseres Klassenobjekts. Dies ist notwendig, damit wir die Methode, die wir testen, auf etwas aufrufen können. Ohne diese Objektinstanz können wir die Methode nicht testen.

Abschnitt 7:

Mit der Methode verknüpfte Variablen müssen festgelegt werden. Daher deklarieren wir hier Variablen, die unserer Methode entsprechen. Diesen sollten aussagekräftige Werte zugewiesen werden (Hinweis: Wenn ein Parameter ein Objekt ist, kann man ihn instanziieren oder verspotten), damit unser Test eine Bedeutung hat.

Abschnitt 8:

Diese Variablendeklaration könnte als optional angesehen werden, lohnt sich jedoch aus Gründen der Organisation und Lesbarkeit. Wir ordnen die Ergebnisse unserer getesteten Methode dieser Variablen zu und verwenden sie nach Bedarf für Zusicherungen und dergleichen.

Abschnitt 9:

Die Assert-Methoden (die Teil der org.junit.Assert-Klasse sind) werden zum Bestimmen des Pass / Fail-Status von Testfällen verwendet. Es werden nur fehlgeschlagene Zusicherungen aufgezeichnet. Wie bei Anmerkungen gibt es viele Assert-Optionen. In unserem obigen Beispiel JUnit verwenden wir assertEquals (erwartet, tatsächlich, Delta). Dies nimmt die erwartetes Ergebnis, die der Benutzer definiert, die präsentieren, was das Ergebnis der aufgerufenen Methode ist, und die DeltaDies ermöglicht die Implementierung einer zulässigen Abweichung zwischen erwarteten und tatsächlichen Werten. Der Zweck einer Behauptung ist die Validierung. Obwohl es nicht erforderlich ist, Ihre JUnit auszuführen, kann das Versäumnis, Zusicherungen hinzuzufügen, den Zweck Ihres Tests zunichte machen. Ohne Behauptungen haben Sie keine Überprüfung und höchstens einen Rauchtest, der nur dann Feedback gibt, wenn Testfehler auftreten.

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 eine JUnit über die Befehlszeile aus

Um eine JUnit direkt über die Befehlszeile auszuführen, benötigen Sie einige Dinge: JDK in Ihrem Pfad, unformatierte Junit-JAR-Datei und 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: In einer professionellen Umgebung ist es unwahrscheinlich, dass ein Test manuell über die Befehlszeile ausgeführt wird, ohne ein Build-System, aber die Fähigkeit ist vorhanden.

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

Eclipse

Um von Eclipse aus ausgeführt zu werden, suchen Sie in Ihrem Paket-Explorer Ihren JUnit-Test in dem Ordner, für den Sie ihn festgelegt haben. Klicken Sie mit der rechten Maustaste und gehen Sie nach unten zu Als JUnit-Test ausführen. Dadurch wird Ihr Test ausgeführt und ein neues JUnit-Fenster geöffnet, falls es noch nicht geöffnet ist.

IntelliJ

Das Ausführen eines Tests in IntelliJ ist Eclipse sehr ähnlich. Suchen Sie im Projektfenster nach test, klicken Sie mit der rechten Maustaste und wählen Sie 'testName' ausführen. Wie bei Eclipse wird ein JUnit-Fenster mit den Testergebnissen geöffnet.

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

Maven

Maven hat das Ausführen von Tests vereinfacht. Stellen Sie sicher, dass Sie sich über Ihre Befehlszeile am richtigen Speicherort befinden und das Projekt pom.xml ordnungsgemäß konfiguriert ist. Anschließend 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 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 einzelne / spezifische Tests durch:

gradlew -Dtest.single=testName test

HINWEIS: Maven und Gradle sind ihr eigenes Monster - was hier gezeigt wird, ist minimal, um die Grundlagen zu behandeln. Lesen Sie die Dokumentation, wenn Sie mehr erfahren möchten.

Fortsetzung des Unit-Tests

In unserem Beispiel wurde ein sehr einfacher Codeausschnitt durchlaufen, und dies ist natürlich nur der Beginn des Komponententests. Komplexere Methoden rufen Datenbanken oder andere Methoden auf, aber um die Funktionalität zu gewährleisten, benötigen wir Isolation, die wir durch erreichen Verspottung. Mocking hilft uns, Codeeinheiten zu isolieren, um unsere Validierung zu fokussieren (Frameworks, die üblicherweise zum Verspotten verwendet werden, sind Mockito und PowerMock). Um mehr über das Verspotten zu erfahren, lesen Sie den Beitrag meines Kollegen: So automatisieren Sie einen Java-Komponententest, einschließlich Verspottungen und Behauptungen.

Also, wenn Unit-Tests so erstaunlich sind, warum sind dann nicht alle großartig darin? Nun, Unit-Tests sind einfach nicht einfach zu implementieren. Es erfordert viel Entwicklungskompetenz und Zeit, Entwickler neigen dazu, es nicht sehr zu genießen, und es erfordert Engagement und Zeit, um Testsuiten zu warten.

Die Vorteile von Unit-Tests liegen jedoch auf der Hand:

  • Isolierung und gezielte Prüfung
  • Sicherstellung des Verhaltens einzelner Methoden oder Methoden
  • Hilft sicherzustellen, dass das Hinzufügen oder Ändern von Code die Anwendung nicht beschädigt
  • Grenzanalyse - Überprüfung auf ungültige / fehlerhafte Eingabe
  • Testen Sie jeden Aspekt der Methode (Abdeckung)
  • Berichterstattung

Daher ist es hilfreich, leistungsstarke Unit-Test-Tools wie z Parasoft Jtest Dies kann viele der mit JUnits verbundenen Probleme beheben und Entwicklern wertvolle Zeit sparen. Parasoft Jtests Unit-Test-Assistent Er nimmt sich Zeit und reduziert die Generierungszeit für JUnit-Tests, indem dem Benutzer eine Anleitung zum Erstellen von Tests mit intuitiven Ein-Klick-Aktionen gegeben wird. Die Wartbarkeit wird mit automatischen Empfehlungen behandelt, die beispielsweise instabile Testumgebungen (und andere Risiken), Bestätigungsempfehlungen und mehr identifizieren.

Laden Sie eine kostenlose Testversion des herunter, um mehr darüber zu erfahren, wie Sie die Schmerzen lindern und Ihre Unit-Tests verbessern können Parasoft Jtest Unit-Test-Assistent. Es ist kostenlos, einfach einzurichten und Sie können allen Tutorials folgen  effizient loslegen.

JUnit-Grundlagen: Erste Schritte mit JUnit und Verwenden der Automatisierung zum Erstellen von Komponententests
Geschrieben von

David Chacon

Erhalten Sie die neuesten Nachrichten und Ressourcen zum Testen von Software sofort.