Java >> Java Tutorial >  >> Tag >> maven

JUnit 5-Tutorial:Unit-Tests mit Maven ausführen

maven

Dieser Blog-Beitrag beschreibt, wie wir ein Maven-Projekt erstellen können, das Unit-Tests kompilieren und ausführen kann, die JUnit 5 verwenden. Nachdem wir diesen Blog-Beitrag beendet haben, werden wir:

  • Kann die erforderlichen Abhängigkeiten mit Maven erhalten.
  • Verstehen, wie wir das Maven Surefire Plugin konfigurieren können.
  • Wissen, wie wir unsere Komponententests mit Maven ausführen können.

Beginnen wir damit, die erforderlichen Abhängigkeiten abzurufen.

Erforderliche Abhängigkeiten abrufen

Wir können die erforderlichen Abhängigkeiten erhalten, indem wir den junit-jupiter hinzufügen (Version 5.8.2) Abhängigkeit von test Umfang. Dies ist ein Aggregator-Artefakt, das die Abhängigkeitsverwaltung vereinfacht, da es die folgenden transitiven Abhängigkeiten hat:

  • Die junit-jupiter-api Abhängigkeit (compile scope) stellt die öffentliche API zum Schreiben von Tests und Erweiterungen bereit.
  • Der junit-jupiter-params Abhängigkeit (compile scope) unterstützt das Schreiben parametrisierter Tests.
  • Der junit-jupiter-engine Abhängigkeit (runtime scope) enthält die Implementierung der JUnit-Jupiter-Test-Engine, die unsere Unit-Tests ausführt. Wenn wir diese Abhängigkeit zu unserem Klassenpfad hinzufügen, können die Maven Surefire- und Failsafe-Plugins (Version 2.22.0 oder neuer) Tests ausführen, die JUnit 5 verwenden.

Nachdem wir die erforderliche Abhängigkeit zu unserer POM-Datei hinzugefügt haben, ist deren dependencies Abschnitt sieht wie folgt aus:

<dependencies>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.8.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Nachdem wir die erforderlichen Abhängigkeiten deklariert haben, müssen wir das Maven Surefire Plugin konfigurieren. Lassen Sie uns herausfinden, wie wir es tun können.

Konfigurieren des Maven Surefire-Plugins

Wir können unsere Unit-Tests mit dem Maven Surefire Plugin ausführen. Da wir die native JUnit 5-Unterstützung nutzen wollen, müssen wir die Version 2.22.0 (oder neuer) verwenden.

Nachdem wir sichergestellt haben, dass unsere Unit-Tests vom Maven Surefire Plugin 2.22.2 ausgeführt werden, wird der build Abschnitt unserer POM-Datei sieht wie folgt aus:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.22.2</version>
        </plugin>
    </plugins>
</build>

Wir haben jetzt ein Maven-Projekt erstellt, das Unit-Tests ausführen kann, die JUnit 5 verwenden. Fahren wir fort und schreiben einen einfachen Unit-Test mit JUnit 5.

Einen einfachen Einheitentest schreiben

Bevor wir Komponententests schreiben können, die JUnit 5 verwenden, müssen wir diese beiden Dinge wissen:

  • Die src/test/java Verzeichnis enthält den Quellcode unserer Unit-Tests.
  • Die src/test/resources Verzeichnis enthält die Ressourcen unserer Unit-Tests.

Lassen Sie uns eine neue Testklasse erstellen und der erstellten Klasse eine leere Testmethode hinzufügen. Nachdem wir unsere Testklasse geschrieben haben, sieht ihr Quellcode wie folgt aus:

import org.junit.jupiter.api.Test;

class JUnit5ExampleTest {

    @Test
    void justAnExample() {

    }
}

Als nächstes werden wir herausfinden, wie wir unsere Komponententests ausführen können.

Einheitentests mit Maven ausführen

Wir können unsere Komponententests mit Maven ausführen, indem wir den folgenden Befehl verwenden:mvn clean test . Wenn wir diesen Befehl an der Eingabeaufforderung ausführen, sollten wir sehen, dass das Maven Surefire-Plugin unsere Komponententests ausführt.

[INFO]
[INFO] --- maven-surefire-plugin:2.22.2:test (default-test) @ running-unit-tests ---
[INFO]
-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running net.petrikainulainen.junit5.JUnit5ExampleTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.033 sec - 
in net.petrikainulainen.junit5.JUnit5ExampleTest

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

Wir können jetzt ein Maven-Projekt erstellen, das Unit-Tests kompiliert und ausführt, die JUnit 5 verwenden. Außerdem wissen wir, wie wir unsere Unit-Tests mit Maven ausführen können. Fassen wir zusammen, was wir aus diesem Blogbeitrag gelernt haben.

Zusammenfassung

Dieser Blogpost hat uns sechs Dinge beigebracht:

  • Die junit-jupiter-api Abhängigkeit stellt die öffentliche API bereit, die es uns ermöglicht, Tests und Erweiterungen zu schreiben, die JUnit 5 verwenden.
  • Die junit-jupiter-engine Abhängigkeit stellt sicher, dass das Maven Surefire Plugin Tests ausführen kann, die JUnit 5 verwenden.
  • Die junit-jupiter Abhängigkeit ist ein Aggregator-Artefakt, das die Abhängigkeitsverwaltung vereinfacht, da es sicherstellt, dass die erforderlichen Abhängigkeiten aus dem Klassenpfad gefunden werden.
  • Das Maven Surefire Plugin 2.22.0 (oder neuer) bietet native Unterstützung für JUnit 5.
  • Wenn wir die native JUnit 5-Unterstützung des Maven Surefire-Plug-ins verwenden möchten, müssen wir sicherstellen, dass mindestens eine Test-Engine-Implementierung im Klassenpfad gefunden wird.
  • Wir können unsere Komponententests mit dem folgenden Befehl ausführen:mvn clean test .

No
Java-Tag