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

Ausführen von Kotlin-Tests mit Maven

maven

Wenn wir ein neues Projekt mit Kotlin starten, müssen wir als Erstes ein Maven-Projekt erstellen, das unsere Anwendung kompilieren und ausführen kann. Allerdings ist unsere Arbeit noch nicht getan. Wir müssen noch einen Weg finden, unsere automatisierten Tests zu kompilieren und auszuführen. Dieser Blogbeitrag hilft uns bei der Erstellung eines Maven-Projekts, das sowohl Unit- als auch Integrationstests kompilieren und ausführen kann, die JUnit 5 verwenden.

Nachdem wir diesen Blogbeitrag fertiggestellt haben, werden wir:

  • Kann ein Maven-Projekt erstellen, das Einheiten- und Integrationstests kompilieren kann, die Kotlin verwenden.
  • Wissen, wie wir benutzerdefinierte Quell- und Ressourcenverzeichnisse zu unserem Maven-Build hinzufügen können.
  • Verstehen Sie, wie wir entweder Einheiten- oder Integrationstests überspringen können.
  • Wissen, wie wir die aufgerufenen Tests mit JUnit 5-Tags filtern können.
  • Kann sowohl Einheiten- als auch Integrationstests mit Maven ausführen.

Beginnen wir damit, einen Blick auf die Anforderungen unseres Maven-Builds zu werfen.

Die Anforderungen unseres Maven-Builds

Die Anforderungen unseres Maven Build sind:

  • Der gesamte Code (Anwendung und Tests) muss Kotlin verwenden.
  • Einheiten- und Integrationstests müssen separate Quell- und Ressourcenverzeichnisse haben.
  • Es muss möglich sein, nur Einheiten- oder Integrationstests auszuführen.
  • Es muss möglich sein, sowohl Unit- als auch Integrationstests auszuführen.
  • Nur Einheitentests werden standardmäßig ausgeführt.

Als nächstes werfen wir einen Blick auf das zu testende System.

Einführung in das zu testende System

In diesem Blogbeitrag werden wir sowohl Unit- als auch Integrationstests für MessageService schreiben Klasse. Diese Klasse hat eine Methode namens getMessage() was die Nachricht zurückgibt:'Hello World!'.

Der Quellcode von MessageService Klasse sieht wie folgt aus:

class MessageService {

 fun getMessage(): String {
 return "Hello World!"
 }
}

Lassen Sie uns weitermachen und herausfinden, wie wir ein einfaches Kotlin-Projekt erstellen können, das nur Komponententests ausführen kann.

Einheitentests mit Maven ausführen

Wenn wir ein Kotlin-Projekt erstellen möchten, das nur Komponententests ausführen kann, müssen wir die folgenden Schritte ausführen:

Zuerst , müssen wir drei Eigenschaften angeben:

  • Die kotlin.version -Eigenschaft gibt die verwendete Kotlin-Version an.
  • Die kotlin.compiler.incremental -Eigenschaft aktiviert die inkrementelle Kompilierung.
  • Der junit-jupiter.version Eigenschaft gibt die verwendete JUnit 5 Version an.

Nachdem wir diese Eigenschaften angegeben haben, wird der properties Abschnitt unserer POM-Datei sieht wie folgt aus:

<properties>
 <kotlin.version>1.3.21</kotlin.version>
 <kotlin.compiler.incremental>true</kotlin.compiler.incremental>
 <junit-jupiter.version>5.4.2</junit-jupiter.version>
</properties>

Zweiter , müssen wir die erforderlichen Abhängigkeiten angeben. Da wir Tests für eine Kotlin-Anwendung unter Verwendung von Kotlin und JUnit 5 schreiben möchten, müssen wir die folgenden Abhängigkeiten angeben:

  • Die Kotlin-Standardbibliothek (kotlin-stdlib ).
  • AssertJ Core.
  • Die Abhängigkeiten von JUnit 5 (JUnit Jupiter API und JUnit Jupiter Engine).

Nachdem wir die erforderlichen Abhängigkeiten angegeben haben, wird die Datei dependencies Abschnitt unserer POM-Datei sieht wie folgt aus:

<dependencies>
 <dependency>
 <groupId>org.jetbrains.kotlin</groupId>
 <artifactId>kotlin-stdlib</artifactId>
 <version>${kotlin.version}</version>
 </dependency>

 <!-- Testing Dependencies -->
 <dependency>
 <groupId>org.assertj</groupId>
 <artifactId>assertj-core</artifactId>
 <version>3.12.2</version>
 <scope>test</scope>
 </dependency>
 <dependency>
 <groupId>org.junit.jupiter</groupId>
 <artifactId>junit-jupiter-api</artifactId>
 <version>${junit-jupiter.version}</version>
 <scope>test</scope>
 </dependency>
 <dependency>
 <groupId>org.junit.jupiter</groupId>
 <artifactId>junit-jupiter-engine</artifactId>
 <version>${junit-jupiter.version}</version>
 <scope>test</scope>
 </dependency>
</dependencies>

Dritter , müssen wir die Quell- und Testverzeichnisse unseres Maven-Builds konfigurieren. Wir werden die folgenden Verzeichnisse verwenden:

  • Die src/main/kotlin Verzeichnis enthält den Quellcode unserer Anwendung.
  • Der src/test/kotlin Verzeichnis enthält den Quellcode unserer Unit-Tests.

Nachdem wir diese Verzeichnisse konfiguriert haben, wird die Datei build Abschnitt unserer POM-Datei sieht wie folgt aus:

<build>
 <sourceDirectory>${project.basedir}/src/main/kotlin</sourceDirectory>
 <testSourceDirectory>${project.basedir}/src/test/kotlin</testSourceDirectory>
</build>

Vierter , müssen wir sicherstellen, dass Maven unseren Kotlin-Code kompiliert. Wir können dies tun, indem wir diesen Schritten folgen:

  1. Fügen Sie das Kotlin Maven-Plugin zu unserem Maven-Build hinzu.
  2. Erstellen Sie eine Ausführung, die compile aufruft Ziel des Kotlin Maven Plugins.
  3. Erstellen Sie eine Ausführung, die test-compile aufruft Ziel des Kotlin Maven Plugins.

Nachdem wir das Kotlin Maven Plugin in der plugins konfiguriert haben Abschnitt unserer POM-Datei sieht seine Konfiguration wie folgt aus:

<plugin>
 <artifactId>kotlin-maven-plugin</artifactId>
 <groupId>org.jetbrains.kotlin</groupId>
 <version>${kotlin.version}</version>

 <executions>
 <execution>
 <id>compile</id>
 <goals>
 <goal>compile</goal>
 </goals>
 </execution>

 <execution>
 <id>test-compile</id>
 <goals>
 <goal>test-compile</goal>
 </goals>
 </execution>
 </executions>
</plugin>

Fünfter , müssen wir sicherstellen, dass Maven unsere Komponententests mit dem Maven Surefire-Plugin (Version 2.22.1) ausführt. Wir können dies tun, indem wir das folgende Snippet zum plugins hinzufügen Abschnitt unserer POM-Datei:

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

Wir haben jetzt unseren Maven-Build konfiguriert. Bevor wir jedoch unsere Komponententests ausführen können, müssen wir eine Testklasse schreiben und diese Klasse in src/test/kotlin ablegen Verzeichnis. Der Quellcode unserer Testklasse sieht wie folgt aus:

import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test

class MessageServiceTest {

 private lateinit var service: MessageService

 @BeforeEach
 fun configureSystemUnderTest() {
 service = MessageService()
 }

 @Test
 @DisplayName("Should return the correct message")
 fun shouldReturnCorrectMessage() {
 val message = service.getMessage()
 assertThat(message).isEqualTo("Hello World!")
 }
}

Wir können jetzt unsere Komponententests mit dem folgenden Befehl ausführen:mvn clean test . Wenn wir diesen Befehl ausführen, sollten wir sehen, dass das Maven Surefire-Plugin unseren Komponententest ausführt:

[INFO] -------------------------------------------------------
[INFO] T E S T S
[INFO] -------------------------------------------------------
[INFO] Running com.testwithspring.master.kotlin.MessageServiceTest
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.049 s - 
in com.testwithspring.master.kotlin.MessageServiceTest
[INFO]
[INFO] Results:
[INFO]
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

Wir haben also gerade ein Maven-Projekt erstellt, das unsere Komponententests kompilieren und ausführen kann. Unser Build bietet jedoch keine Unterstützung für Integrationstests. Als Nächstes werden wir herausfinden, wie wir sowohl Unit- als auch Integrationstests unterstützen können.

Einheiten- und Integrationstests mit Maven ausführen

Da wir mit Maven sowohl Unit- als auch Integrationstests durchführen wollen, müssen wir einige Änderungen an unserem Maven-Build vornehmen. Beginnen wir mit der Konfiguration der Quell- und Ressourcenverzeichnisse unseres Maven-Builds.

Konfigurieren der Quell- und Ressourcenverzeichnisse

Wir können die Quell- und Ressourcenverzeichnisse unserer Einheiten- und Integrationstests konfigurieren, indem wir diesen Schritten folgen:

Zuerst , haben wir das Ressourcenverzeichnis unserer Integrationstests zu unserem Maven-Build hinzugefügt. Wir können dies tun, indem wir das Build Helper Maven-Plugin verwenden. Wenn wir dieses Plugin verwenden möchten, müssen wir die folgenden Schritte ausführen:

  1. Fügen Sie das Build Helper Maven-Plugin zu unserem Maven-Build hinzu.
  2. Erstellen Sie eine Ausführung, die src/integration-test/resources hinzufügt Verzeichnis zu unserem Maven-Build.

Nachdem wir das Build Helper Maven-Plugin konfiguriert haben, sieht seine Konfiguration wie folgt aus:

<plugin>
 <groupId>org.codehaus.mojo</groupId>
 <artifactId>build-helper-maven-plugin</artifactId>
 <version>3.0.0</version>
 <executions>
 <execution>
 <id>add-integration-test-resources</id>
 <phase>generate-test-resources</phase>
 <goals>
 <goal>add-test-resource</goal>
 </goals>
 <configuration>
 <resources>
 <resource>
 <filtering>true</filtering>
 <directory>src/integration-test/resources</directory>
 </resource>
 </resources>
 </configuration>
 </execution>
 </executions>
</plugin>

Zweiter , da unsere Unit- und Integrationstests separate Quellverzeichnisse haben, müssen wir sicherstellen, dass Maven den Quellcode unserer Unit- und Integrationstests kompilieren kann. Wir können dies tun, indem wir diesen Schritten folgen:

  1. Entfernen Sie testSourceDirectory Element aus build Abschnitt unserer POM-Datei.
  2. Stellen Sie sicher, dass das Kotlin-Maven-Plugin den Quellcode aus src/test/kotlin kompilieren kann und src/integration-test/kotlin Verzeichnisse.

Nachdem wir diese Änderungen an unserem Maven-Build vorgenommen haben, sieht die Konfiguration des Kotlin-Maven-Plugins wie folgt aus:

<plugin>
 <artifactId>kotlin-maven-plugin</artifactId>
 <groupId>org.jetbrains.kotlin</groupId>
 <version>${kotlin.version}</version>
 <executions>
 <execution>
 <id>compile</id>
 <goals>
 <goal>compile</goal>
 </goals>
 </execution>
 <execution>
 <id>test-compile</id>
 <goals>
 <goal>test-compile</goal>
 </goals>
 <configuration>
 <sourceDirs>
 <sourceDir>${project.basedir}/src/test/kotlin</sourceDir>
 <sourceDir>${project.basedir}/src/integration-test/kotlin</sourceDir>
 </sourceDirs>
 </configuration>
 </execution>
 </executions>
</plugin>

Nachdem wir die Quell- und Ressourcenverzeichnisse unserer Unit- und Integrationstests konfiguriert haben, müssen wir sicherstellen, dass wir unsere Integrationstests Maven ausführen können.

Durchführen von Integrationstests mit Maven

Wir können unsere Integrationstests mit Maven ausführen, indem wir das Maven Failsafe-Plugin (Version 2.22.1) verwenden. Wir können dieses Plugin zu unserem Maven-Build hinzufügen, indem wir das folgende Snippet zu plugins hinzufügen Abschnitt unserer POM-Datei:

<plugin>
 <groupId>org.apache.maven.plugins</groupId>
 <artifactId>maven-failsafe-plugin</artifactId>
 <version>2.22.1</version>
</plugin>

Nachdem wir das Maven Failsafe-Plugin zu unserem Maven-Build hinzugefügt haben, müssen wir es wie folgt konfigurieren:

  1. Stellen Sie sicher, dass das Maven Failsafe-Plugin alle Testklassen ausführt, deren Name mit dem Suffix endet:Test . Wir können dies tun, indem wir das Wildcard-Muster ändern, das verwendet wird, um die aufgerufenen Testklassen auszuwählen.
  2. Stellen Sie sicher, dass das Maven Failsafe-Plugin sowohl integration-test ausführt und verify Tore. Die integration-test Goal führt unsere Integrationstests und den verify aus Goal überprüft die Ergebnisse unserer Integrationstests und lässt den Build fehlschlagen, wenn unsere Integrationstests fehlschlagen.

Nachdem wir das Maven Failsafe-Plugin konfiguriert haben, sieht seine Konfiguration wie folgt aus:

<plugin>
 <groupId>org.apache.maven.plugins</groupId>
 <artifactId>maven-failsafe-plugin</artifactId>
 <version>2.22.1</version>
 <configuration>
 <includes>
 <include>**/*Test.java</include>
 </includes>
 </configuration>
 <executions>
 <execution>
 <id>integration-tests</id>
 <goals>
 <goal>integration-test</goal>
 <goal>verify</goal>
 </goals>
 </execution>
 </executions>
</plugin>

Nachdem wir das Maven Failsafe-Plugin konfiguriert haben, müssen wir die Maven-Profile erstellen, mit denen wir entweder Unit-Tests, Integrationstests oder alle Tests ausführen können. Lassen Sie uns weitermachen und herausfinden, wie wir diese Maven-Profile erstellen können.

Erstellen der erforderlichen Maven-Profile

Wir können die erforderlichen Maven-Profile erstellen, indem wir diesen Schritten folgen:

Zuerst , müssen wir die Standardwerte der folgenden Eigenschaften angeben:

  • Der Wert von skip.integration.tests -Eigenschaft gibt an, ob unser Build unsere Integrationstests überspringen soll. Da standardmäßig nur Einheitentests ausgeführt werden, muss der Standardwert dieser Eigenschaft true sein .
  • Der Wert von skip.unit.tests -Eigenschaft definiert, ob unser Build unsere Komponententests überspringen soll. Da standardmäßig nur Komponententests ausgeführt werden, muss der Standardwert dieser Eigenschaft wieder false sein .

Nachdem wir diese Standardwerte festgelegt haben, wird der properties Abschnitt unserer POM-Datei sieht wie folgt aus:

<properties>
 <kotlin.version>1.3.11</kotlin.version>
 <kotlin.compiler.incremental>true</kotlin.compiler.incremental>
 <junit-jupiter.version>5.3.2</junit-jupiter.version>

 <skip.integration.tests>true</skip.integration.tests>
 <skip.unit.tests>false</skip.unit.tests>
</properties>

Zweiter , müssen wir drei Maven-Profile erstellen:

  • Der dev profile ist das Standardprofil unseres Maven-Builds und führt nur Unit-Tests aus.
  • Der integration-test Profil führt nur Integrationstests aus.
  • Der all-tests Profil führt sowohl Einheiten- als auch Integrationstests aus.

Nachdem wir diese Maven-Profile erstellt haben, wird der profiles Abschnitt unserer POM-Datei sieht wie folgt aus:

<profiles>
 <profile>
 <id>dev</id>
 <activation>
 <activeByDefault>true</activeByDefault>
 </activation>
 </profile>
 <profile>
 <id>integration-test</id>
 <properties>
 <skip.integration.tests>false</skip.integration.tests>
 <skip.unit.tests>true</skip.unit.tests>
 </properties>
 </profile>
 <profile>
 <id>all-tests</id>
 <properties>
 <skip.integration.tests>false</skip.integration.tests>
 <skip.unit.tests>false</skip.unit.tests>
 </properties>
 </profile>
</profiles>

Dritter , müssen wir sicherstellen, dass das Maven Surefire-Plugin unsere Komponententests nicht ausführt, wenn der Wert von skip.unit.tests Eigenschaft ist true . Nachdem wir diese Änderung an der Konfiguration des Maven Surefire-Plugins vorgenommen haben, sieht seine Konfiguration wie folgt aus:

<plugin>
 <groupId>org.apache.maven.plugins</groupId>
 <artifactId>maven-surefire-plugin</artifactId>
 <version>2.22.1</version>
 <configuration>
 <skipTests>${skip.unit.tests}</skipTests>
 </configuration>
</plugin>

Vierter müssen wir sicherstellen, dass das Maven Failsafe-Plugin unsere Integrationstests nicht ausführt, wenn der Wert von skip.integration.tests Eigenschaft ist true . Nachdem wir diese Änderung an der Konfiguration des Maven Failsafe-Plugins vorgenommen haben, sieht seine Konfiguration wie folgt aus:

<plugin>
 <groupId>org.apache.maven.plugins</groupId>
 <artifactId>maven-failsafe-plugin</artifactId>
 <version>2.22.1</version>
 <configuration>
 <includes>
 <include>**/*Test.java</include>
 </includes>
 </configuration>
 <executions>
 <execution>
 <id>integration-tests</id>
 <goals>
 <goal>integration-test</goal>
 <goal>verify</goal>
 </goals>
 <configuration>
 <skipTests>${skip.integration.tests}</skipTests>
 </configuration>
 </execution>
 </executions>
</plugin>

Wir haben jetzt die erforderlichen Maven-Profile erstellt. Als nächstes werden wir herausfinden, wie wir die aufgerufenen Tests mithilfe von JUnit 5-Tags filtern können.

Filtern der aufgerufenen Tests mit JUnit 5-Tags

Da die Maven Surefire- und Failsafe-Plugins dasselbe Include-Muster verwenden, müssen wir die aufgerufenen Tests mithilfe von JUnit 5-Tags filtern. Wir können dies tun, indem wir diesen Schritten folgen:

Zuerst , müssen wir sicherstellen, dass das Maven Surefire-Plugin nur Tests ausführt, die das Tag:unitTest haben . Nachdem wir die erforderlichen Änderungen an der Konfiguration des Maven Surefire-Plugins vorgenommen haben, sieht es wie folgt aus:

<plugin>
 <groupId>org.apache.maven.plugins</groupId>
 <artifactId>maven-surefire-plugin</artifactId>
 <version>2.22.1</version>
 <configuration>
 <groups>unitTest</groups>
 <skipTests>${skip.unit.tests}</skipTests>
 </configuration>
</plugin>

Zweiter , müssen wir sicherstellen, dass das Maven Failsafe-Plugin nur Tests ausführt, die das Tag:integrationTest haben . Nachdem wir die erforderlichen Änderungen an der Konfiguration des Maven Failsafe Plugins vorgenommen haben, sieht es wie folgt aus:

<plugin>
 <groupId>org.apache.maven.plugins</groupId>
 <artifactId>maven-failsafe-plugin</artifactId>
 <version>2.22.1</version>
 <configuration>
 <groups>integrationTest</groups>
 <includes>
 <include>**/*Test.java</include>
 </includes>
 </configuration>
 <executions>
 <execution>
 <id>integration-tests</id>
 <goals>
 <goal>integration-test</goal>
 <goal>verify</goal>
 </goals>
 <configuration>
 <skipTests>${skip.integration.tests}</skipTests>
 </configuration>
 </execution>
 </executions>
</plugin>

Dritter , müssen wir sicherstellen, dass unsere Unit-Test-Klasse das Tag hat:unitTest . Nachdem wir dieses Tag zu unserer Unit-Test-Klasse hinzugefügt haben, sieht sein Quellcode wie folgt aus:

import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test

@Tag("unitTest")
class MessageServiceTest {

 private lateinit var service: MessageService

 @BeforeEach
 fun configureSystemUnderTest() {
 service = MessageService()
 }

 @Test
 @DisplayName("Should return the correct message")
 fun shouldReturnCorrectMessage() {
 val message = service.getMessage()
 assertThat(message).isEqualTo("Hello World!")
 }
}

Vierter , müssen wir eine Integrationstestklasse schreiben, die sicherstellt, dass das zu testende System die richtige Nachricht zurückgibt. Nachdem wir diese Klasse geschrieben haben, sieht ihr Quellcode wie folgt aus:

import org.assertj.core.api.Assertions
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test

@Tag("integrationTest")
class GetMessageTest {

 private lateinit var service: MessageService

 @BeforeEach
 fun configureSystemUnderTest() {
 service = MessageService()
 }

 @Test
 @DisplayName("Should return the correct message")
 fun shouldReturnCorrectMessage() {
 val message = service.getMessage()
 Assertions.assertThat(message).isEqualTo("Hello World!")
 }
}

Wir haben unserem Maven-Build jetzt Unterstützung für Integrationstests hinzugefügt. Fahren wir fort und finden heraus, wie wir unsere Einheiten- und Integrationstests ausführen können.

Durchführung unserer Tests

Wenn wir nur Komponententests ausführen möchten, müssen wir den Befehl ausführen:mvn clean test -P dev . Wenn wir diesen Befehl an der Eingabeaufforderung ausführen, sehen wir, dass Maven nur unsere Komponententests ausführt:

[INFO] --- maven-surefire-plugin:2.22.1:test (default-test) 
@ running-kotlin-tests-with-maven ---
[INFO]
[INFO] -------------------------------------------------------
[INFO] T E S T S
[INFO] -------------------------------------------------------
[INFO] Running com.testwithspring.master.kotlin.MessageServiceTest
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.046 s - 
in com.testwithspring.master.kotlin.MessageServiceTest
[INFO]
[INFO] Results:
[INFO]
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

Wenn wir nur Integrationstests ausführen möchten, müssen wir den Befehl ausführen:mvn clean verify -P integration-test . Wenn wir diesen Befehl an der Eingabeaufforderung ausführen, sehen wir, dass Maven unsere Komponententests überspringt und nur unsere Integrationstests ausführt:

[INFO] --- maven-surefire-plugin:2.22.1:test (default-test) 
@ running-kotlin-tests-with-maven ---
[INFO] Tests are skipped.
[INFO]
[INFO] --- maven-failsafe-plugin:2.22.1:integration-test (integration-tests) 
@ running-kotlin-tests-with-maven ---
[INFO]
[INFO] -------------------------------------------------------
[INFO] T E S T S
[INFO] -------------------------------------------------------
[INFO] Running com.testwithspring.master.kotlin.GetMessageTest
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.043 s - 
in com.testwithspring.master.kotlin.GetMessageTest
[INFO]
[INFO] Results:
[INFO]
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO]
[INFO] --- maven-failsafe-plugin:2.22.1:verify (integration-tests) 
@ running-kotlin-tests-with-maven ---

Wenn wir sowohl Komponenten- als auch Integrationstests ausführen möchten, müssen wir den folgenden Befehl ausführen:mvn clean verify -P all-tests . Wenn wir diesen Befehl an der Eingabeaufforderung ausführen, sehen wir, dass Maven unsere Einheiten- und Integrationstests ausführt:

[INFO] --- maven-surefire-plugin:2.22.1:test (default-test) 
@ running-kotlin-tests-with-maven ---
[INFO]
[INFO] -------------------------------------------------------
[INFO] T E S T S
[INFO] -------------------------------------------------------
[INFO] Running com.testwithspring.master.kotlin.MessageServiceTest
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.056 s - 
in com.testwithspring.master.kotlin.MessageServiceTest
[INFO]
[INFO] Results:
[INFO]
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO] --- maven-failsafe-plugin:2.22.1:integration-test (integration-tests) 
@ running-kotlin-tests-with-maven ---
[INFO]
[INFO] -------------------------------------------------------
[INFO] T E S T S
[INFO] -------------------------------------------------------
[INFO] Running com.testwithspring.master.kotlin.GetMessageTest
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.058 s - 
in com.testwithspring.master.kotlin.GetMessageTest
[INFO]
[INFO] Results:
[INFO]
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO]
[INFO] --- maven-failsafe-plugin:2.22.1:verify (integration-tests) 
@ running-kotlin-tests-with-maven ---

Wir können jetzt einen Maven-Build erstellen, der Einheiten- und Integrationstests ausführen kann, die Kotlin und JUnit 5 verwenden. Fassen wir zusammen, was wir aus diesem Blogbeitrag gelernt haben.

Zusammenfassung

Dieser Blogpost hat uns sechs Dinge beigebracht:

  • Wir müssen die Kotlin-Standardbibliothek (kotlin-stdlib ) Abhängigkeit in unserer POM-Datei.
  • Wir müssen unseren Testcode mit dem Kotlin Maven Plugin kompilieren.
  • Wenn unsere Integrationstests Ressourcendateien haben (z. B. DbUnit-Datensätze), müssen wir das Ressourcenverzeichnis zu unserem Maven-Build hinzufügen, indem wir das Build Helper Maven-Plugin verwenden.
  • Wir können unsere Unit-Tests mit dem Maven Surefire Plugin ausführen.
  • Wir können unsere Integrationstests mit dem Maven Failsafe Plugin ausführen.
  • Wir können die aufgerufenen Tests filtern, indem wir Maven-Profile und JUnit-5-Tags verwenden.

Quellcode von Github abrufen .


Java-Tag