Java >> Java tutorial >  >> Tag >> maven

Kører Kotlin-tests med Maven

maven

Når vi starter et nyt projekt med Kotlin, er en af ​​de første ting, vi skal gøre, at skabe et Maven-projekt, der kan kompilere og køre vores applikation. Vores job er dog ikke udført endnu. Vi mangler stadig at finde ud af en måde at kompilere og køre vores automatiserede test på. Dette blogindlæg hjælper os med at skabe et Maven-projekt, der kan kompilere og køre både enheds- og integrationstest, der bruger JUnit 5.

Efter at vi har afsluttet dette blogindlæg, gør vi:

  • Kan oprette et Maven-projekt, der kan kompilere enheds- og integrationstest, der bruger Kotlin.
  • Vid, hvordan vi kan tilføje tilpassede kilde- og ressourcemapper til vores Maven-bygning.
  • Forstå, hvordan vi kan springe enten enheds- eller integrationstest over.
  • Vid, hvordan vi kan filtrere de påkaldte tests med JUnit 5-tags.
  • Kan køre både enheds- og integrationstest med Maven.

Lad os starte med at tage et kig på kravene til vores Maven-bygning.

Kravene til vores Maven-bygning

Kravene til vores Maven Build er:

  • Al kode (applikation og test) skal bruge Kotlin.
  • Enheds- og integrationstest skal have separate kilde- og ressourcemapper.
  • Det skal kun være muligt at køre enheds- eller integrationstest.
  • Det skal være muligt at køre både enheds- og integrationstest.
  • Kun enhedstest køres som standard.

Dernæst vil vi tage et kig på systemet under test.

Introduktion til System under Test

I løbet af dette blogindlæg vil vi skrive både enheds- og integrationstest for MessageService klasse. Denne klasse har en metode kaldet getMessage() som returnerer beskeden:'Hello World!'.

Kildekoden til MessageService klasse ser ud som følger:

class MessageService {

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

Lad os gå videre og finde ud af, hvordan vi kan skabe et simpelt Kotlin-projekt, der kun kan køre enhedstests.

Kørsel af enhedstests med Maven

Når vi vil oprette et Kotlin-projekt, der kun kan køre enhedstests, skal vi følge disse trin:

Først , skal vi angive tre egenskaber:

  • kotlin.version egenskaben angiver den brugte Kotlin-version.
  • kotlin.compiler.incremental egenskaben muliggør trinvis kompilering.
  • junit-jupiter.version egenskaben angiver den brugte JUnit 5-version.

Efter at vi har specificeret disse egenskaber, vil properties sektionen af ​​vores POM-fil ser ud som følger:

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

Anden , skal vi angive de nødvendige afhængigheder. Fordi vi ønsker at skrive test til en Kotlin-applikation ved at bruge Kotlin og JUnit 5, er vi nødt til at angive følgende afhængigheder:

  • Kotlins standardbibliotek (kotlin-stdlib ).
  • AssertJ Core.
  • JUnit 5-afhængighederne (JUnit Jupiter API og JUnit Jupiter-motor).

Efter at vi har specificeret de nødvendige afhængigheder, er dependencies sektionen af ​​vores POM-fil ser ud som følger:

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

Tredje , er vi nødt til at konfigurere kilden og teste mapper for vores Maven build. Vi vil bruge følgende mapper:

  • src/main/kotlin biblioteket indeholder kildekoden til vores applikation.
  • src/test/kotlin biblioteket indeholder kildekoden til vores enhedstests.

Efter at vi har konfigureret disse mapper, vil build sektionen af ​​vores POM-fil ser ud som følger:

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

Fjerde , skal vi sikre, at Maven kompilerer vores Kotlin-kode. Vi kan gøre dette ved at følge disse trin:

  1. Tilføj Kotlin Maven plugin til vores Maven build.
  2. Opret en udførelse, der kalder compile målet for Kotlin Maven-plugin.
  3. Opret en udførelse, der kalder test-compile målet for Kotlin Maven-plugin.

Efter at vi har konfigureret Kotlin Maven-plugin'et i plugins sektion af vores POM-fil, ser dens konfiguration ud som følger:

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

Femte , skal vi sikre, at Maven kører, vores enhedstester køres ved at bruge Maven Surefire plugin (version 2.22.1). Vi kan gøre dette ved at tilføje følgende uddrag til plugins sektion af vores POM-fil:

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

Vi har nu konfigureret vores Maven build. Men før vi kan køre vores enhedstests, skal vi skrive en testklasse og lægge denne klasse til src/test/kotlin vejviser. Kildekoden til vores testklasse ser ud som følger:

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!")
 }
}

Vi kan nu køre vores enhedstest ved at bruge kommandoen:mvn clean test . Når vi kører denne kommando, bør vi se, at Maven Surefire-plugin'et kører vores enhedstest:

[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

Så vi har lige lavet et Maven-projekt, der kan kompilere og køre vores enhedstests. Vores build har dog ingen understøttelse af integrationstest. Dernæst vil vi finde ud af, hvordan vi kan understøtte både enheds- og integrationstests.

Kørsel af enheds- og integrationstest med Maven

Fordi vi ønsker at køre både enheds- og integrationstests med Maven, er vi nødt til at foretage nogle ændringer i vores Maven build. Lad os starte med at konfigurere kilde- og ressourcemapper for vores Maven-build.

Konfiguration af kilde- og ressourcemapper

Vi kan konfigurere kilde- og ressourcemapper for vores enhed og integrationstest ved at følge disse trin:

Først , har vi tilføjet ressourcekataloget for vores integrationstest til vores Maven-build. Vi kan gøre dette ved at bruge Build Helper Maven plugin. Når vi vil bruge dette plugin, skal vi følge disse trin:

  1. Tilføj Build Helper Maven plugin til vores Maven build.
  2. Opret en udførelse, der tilføjer src/integration-test/resources mappe til vores Maven build.

Efter at vi har konfigureret Build Helper Maven-pluginnet, ser dets konfiguration ud som følger:

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

Anden , fordi vores enheds- og integrationstest har separate kildemapper, skal vi sikre, at Maven kan kompilere kildekoden til vores enhed og integrationstest. Vi kan gøre dette ved at følge disse trin:

  1. Fjern testSourceDirectory element fra build afsnittet i vores POM-fil.
  2. Sørg for, at Kotlin Maven-pluginnet kan kompilere kildekoden fundet fra src/test/kotlin og src/integration-test/kotlin mapper.

Efter at vi har foretaget disse ændringer i vores Maven-build, ser konfigurationen af ​​Kotlin Maven-plugin'et ud som følger:

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

Når vi har konfigureret kilde- og ressourcemapper for vores enhed og integrationstest, skal vi sikre, at vi kan køre vores integrationstest Maven.

Køre integrationstest med Maven

Vi kan køre vores integrationstest med Maven ved at bruge Maven Failsafe plugin (version 2.22.1). Vi kan tilføje dette plugin til vores Maven build ved at tilføje følgende uddrag til plugins sektion af vores POM-fil:

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

Efter at vi har tilføjet Maven Failsafe plugin til vores Maven build, skal vi konfigurere det ved at følge disse trin:

  1. Sørg for, at Maven Failsafe-plugin'et kører alle testklasser, hvis navn ender med suffikset:Test . Vi kan gøre dette ved at ændre jokertegnsmønsteret, der bruges til at vælge de påkaldte testklasser.
  2. Sørg for, at Maven Failsafe-plugin'et kører både integration-test og verify mål. integration-test goal kører vores integrationstest og verify mål tjekker resultaterne af vores integrationstest og fejler opbygningen, hvis vores integrationstest mislykkedes.

Efter at vi har konfigureret Maven Failsafe plugin, ser dets konfiguration ud som følger:

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

Efter at vi har konfigureret Maven Failsafe-pluginnet, skal vi oprette Maven-profilerne, som giver os mulighed for at køre enten enhedstest, integrationstest eller alle test. Lad os gå videre og finde ud af, hvordan vi kan oprette disse Maven-profiler.

Oprettelse af de nødvendige Maven-profiler

Vi kan oprette de nødvendige Maven-profiler ved at følge disse trin:

Først , skal vi angive standardværdierne for følgende egenskaber:

  • Værdien af ​​skip.integration.tests egenskab angiver, om vores build skal springe vores integrationstest over. Fordi kun enhedstest køres som standard, skal standardværdien for denne egenskab være true .
  • Værdien af ​​skip.unit.tests egenskab definerer, om vores bygning skal springe vores enhedstests over. Igen, fordi der kun køres enhedstest som standard, skal standardværdien for denne egenskab være false .

Efter at vi har angivet disse standardværdier, er properties sektionen af ​​vores POM-fil ser ud som følger:

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

Anden , skal vi oprette tre Maven-profiler:

  • dev profilen er standardprofilen for vores Maven build, og den kører kun enhedstests.
  • integration-test profilen kører kun integrationstests.
  • all-tests profilen kører både enheds- og integrationstests.

Efter at vi har oprettet disse Maven-profiler, er profiles sektionen af ​​vores POM-fil ser ud som følger:

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

Tredje , skal vi sikre, at Maven Surefire-plugin'et ikke kører vores enhedstests, hvis værdien af ​​skip.unit.tests egenskaben er true . Efter at vi har foretaget denne ændring af konfigurationen af ​​Maven Surefire-plugin'et, ser dets konfiguration ud som følger:

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

Fjerde , skal vi sikre, at Maven Failsafe-pluginnet ikke kører vores integrationstest, hvis værdien af ​​skip.integration.tests egenskaben er true . Efter at vi har foretaget denne ændring af konfigurationen af ​​Maven Failsafe plugin, ser dens konfiguration ud som følger:

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

Vi har nu oprettet de nødvendige Maven-profiler. Dernæst vil vi finde ud af, hvordan vi kan filtrere de påberåbte tests ved at bruge JUnit 5-tags.

Filtrering af de påkaldte tests med JUnit 5-tags

Fordi Maven Surefire- og Failsafe-plugins bruger det samme include-mønster, er vi nødt til at filtrere de påkaldte tests ved at bruge JUnit 5-tags. Vi kan gøre dette ved at følge disse trin:

Først , skal vi sikre, at Maven Surefire-pluginnet kun kører tests, der har tagget:unitTest . Efter at vi har foretaget de nødvendige ændringer af konfigurationen af ​​Maven Surefire-plugin'et, ser det ud som følger:

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

Anden , skal vi sikre, at Maven Failsafe-plugin'et kun kører test, der har tagget:integrationTest . Efter at vi har foretaget de nødvendige ændringer af konfigurationen af ​​Maven Failsafe-plugin'et, ser det ud som følger:

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

Tredje , skal vi sikre, at vores enhedstestklasse har tagget:unitTest . Efter at vi har tilføjet dette tag til vores enhedstestklasse, ser dets kildekode ud som følger:

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!")
 }
}

Fjerde , skal vi skrive en integrationstestklasse, som sikrer, at systemet under test returnerer den korrekte besked. Efter at vi har skrevet denne klasse, ser dens kildekode ud som følger:

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!")
 }
}

Vi har nu tilføjet integrationstestunderstøttelse til vores Maven build. Lad os gå videre og finde ud af, hvordan vi kan køre vores enheds- og integrationstest.

Kør vores tests

Hvis vi kun vil køre enhedstest, skal vi køre kommandoen:mvn clean test -P dev . Når vi kører denne kommando ved kommandoprompt, ser vi, at Maven kun kører vores enhedstest:

[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

Hvis vi kun vil køre integrationstest, skal vi køre kommandoen:mvn clean verify -P integration-test . Når vi kører denne kommando ved kommandoprompt, ser vi, at Maven springer vores enhedstests over og kun kører vores integrationstest:

[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 ---

Hvis vi vil køre både enheds- og integrationstest, skal vi køre kommandoen:mvn clean verify -P all-tests . Når vi kører denne kommando ved kommandoprompt, ser vi, at Maven kører vores enheds- og integrationstest:

[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 ---

Vi kan nu oprette en Maven-build, der kan køre enheds- og integrationstest, som bruger Kotlin og JUnit 5. Lad os opsummere, hvad vi lærte af dette blogindlæg.

Oversigt

Dette blogindlæg har lært os seks ting:

  • Vi er nødt til at erklære Kotlins standardbibliotek (kotlin-stdlib ) afhængighed i vores POM-fil.
  • Vi er nødt til at kompilere vores testkode ved at bruge Kotlin Maven-plugin.
  • Hvis vores integrationstest har ressourcefiler (såsom DbUnit-datasæt), skal vi tilføje ressourcebiblioteket til vores Maven-build ved at bruge Build Helper Maven-plugin'et.
  • Vi kan køre vores enhedstest ved at bruge Maven Surefire Plugin.
  • Vi kan køre vores integrationstest ved at bruge Maven Failsafe Plugin.
  • Vi kan filtrere de påberåbte tests ved at bruge Maven-profiler og JUnit 5-tags.

Hent kildekoden fra Github .


Java tag