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

Schreiben von Komponententests mit Spock Framework:Erstellen eines Maven-Projekts

maven

Das Spock Framework ist ein Test- und Spezifikations-Framework für Java- und Groovy-Anwendungen. Seine Website macht eine etwas gewagte Behauptung:

Was es von der Masse abhebt, ist seine schöne und ausdrucksstarke Spezifikationssprache.

Bevor wir überprüfen können, ob diese Behauptung wahr ist, müssen wir ein Beispielprojekt erstellen, das wir für diesen Zweck verwenden können. Eine Möglichkeit, dies zu tun, ist die Verwendung von Maven.

Dieser Blogbeitrag beschreibt, wie wir ein Maven-Projekt erstellen können, das die folgenden Anforderungen erfüllt:

  • Es muss „normale“ Unit-Tests unterstützen, die JUnit und Unit-Tests verwenden, die das Spock Framework verwenden.
  • Es muss die "normalen" Unit-Tests kompilieren und ausführen, die in src/test/java zu finden sind Verzeichnis.
  • Es muss die Groovy-Einheitentests kompilieren und ausführen, die in src/test/groovy zu finden sind Verzeichnis.
  • Es muss einen HTML-Testbericht erstellen, der die Testergebnisse unserer Komponententests beschreibt, die das Spock Framework verwenden.

Beginnen wir damit, die erforderlichen Abhängigkeiten abzurufen.

Erforderliche Abhängigkeiten abrufen

Wir können die erforderlichen Abhängigkeiten erhalten, indem wir die folgenden Abhängigkeiten in unserer pom.xml deklarieren Datei:

  • JUnit (Version 4.12) ist ein Framework, mit dem wir sowohl Unit- als auch Integrationstests schreiben können.
  • Spock Core (Version 1.0-groovy-2.4). Spock ist ein Test- und Spezifikations-Framework für Java- und Groovy-Anwendungen.
  • Groovy All (Version 2.4.4). Groovy ist eine dynamische Programmiersprache für die JVM.

Nachdem wir diese Abhängigkeiten in unsere pom.xml eingefügt haben Datei, ihre Abhängigkeiten Abschnitt sieht wie folgt aus:

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.spockframework</groupId>
        <artifactId>spock-core</artifactId>
        <version>1.0-groovy-2.4</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.codehaus.groovy</groupId>
        <artifactId>groovy-all</artifactId>
        <version>2.4.4</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Nachdem wir die erforderlichen Abhängigkeiten in unsere pom.xml eingefügt haben -Datei müssen wir Maven konfigurieren, um unsere Unit-Tests zu kompilieren.

Kompilieren unserer Komponententests

Da unsere Komponententests sowohl Java- als auch Groovy-Programmiersprachen verwenden, müssen wir unsere Testquellen mithilfe der GMavenPlus- und Maven-Compiler-Plug-ins kompilieren. Wir können diese Plugins konfigurieren, indem wir diesen Schritten folgen:

  1. Fügen Sie das GMavenPlus Plugin (Version 1.5) in die pom.xml ein Datei und konfigurieren Sie sie, indem Sie diesen Schritten folgen:
    1. Stellen Sie sicher, dass die addTestSources Das Ziel des GMavenPlus-Plug-Ins wird beim Initialisieren aufgerufen Phase des Maven-Standardlebenszyklus. Dieses Ziel fügt unsere Groovy-Testquellen hinzu, die in src/test/groovy zu finden sind Verzeichnis zu den Testquellen des Projekts.
    2. Stellen Sie sicher, dass die Datei testCompile Ziel des GMavenPlus Plugins wird in der Test-Kompilierung aufgerufen Phase des Maven-Standardlebenszyklus. Dieses Ziel kompiliert unsere Groovy-Testquellen.
  2. Fügen Sie das Maven Compiler Plugin (Version 3.3) in die pom.xml ein Datei und konfigurieren Sie sie, indem Sie diesen Schritten folgen:
    1. Stellen Sie sicher, dass der Java-Compiler Code akzeptiert, der Java 1.8 verwendet.
    2. Stellen Sie sicher, dass die kompilierten Klassen mit Java 1.8 kompatibel sind.

Nachdem wir diese Plugins konfiguriert haben, werden die Plugins Abschnitt unserer pom.xml sieht wie folgt aus:

<plugins>
    <plugin>
        <groupId>org.codehaus.gmavenplus</groupId>
        <artifactId>gmavenplus-plugin</artifactId>
        <version>1.5</version>
        <executions>
            <execution>
                <goals>
					<goal>addTestSources</goal>
                    <goal>testCompile</goal>
                </goals>
            </execution>
        </executions>
    </plugin>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.3</version>
        <configuration>
            <source>1.8</source>
            <target>1.8</target>
        </configuration>
    </plugin>
</plugins>

Wir können unsere Komponententests kompilieren, indem wir den folgenden Befehl an der Eingabeaufforderung ausführen:

mvn clean test-compile

Wenn Sie dies tun, sehen wir das

  • Die addTestSources und testCompile Ziele des GMavenPlus Plugins aufgerufen werden.
  • das testCompile Ziel des Maven Compiler Plugins aufgerufen wird.

Die Ausgabe dieses Befehls sieht wie folgt aus:

> mvn clean test-compile
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building Writing Unit Tests With Spock - Configuration 0.1
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ unit-testing-configuration ---
[INFO] Deleting /Users/loke/Projects/Java/Blog/spock-examples/unit-testing/configuration/target
[INFO]
[INFO] --- gmavenplus-plugin:1.5:addTestSources (default) @ unit-testing-configuration ---
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ unit-testing-configuration ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory /Users/loke/Projects/Java/Blog/spock-examples/unit-testing/configuration/src/main/resources
[INFO]
[INFO] --- maven-compiler-plugin:3.3:compile (default-compile) @ unit-testing-configuration ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to /Users/loke/Projects/Java/Blog/spock-examples/unit-testing/configuration/target/classes
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ unit-testing-configuration ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 1 resource
[INFO]
[INFO] --- maven-compiler-plugin:3.3:testCompile (default-testCompile) @ unit-testing-configuration ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to /Users/loke/Projects/Java/Blog/spock-examples/unit-testing/configuration/target/test-classes
[INFO]
[INFO] --- gmavenplus-plugin:1.5:testCompile (default) @ unit-testing-configuration ---
[INFO] Using Groovy 2.4.4 to perform testCompile.
[INFO] Compiled 1 file.
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 2.502 s
[INFO] Finished at: 2015-08-25T20:43:11+03:00
[INFO] Final Memory: 22M/221M
[INFO] ------------------------------------------------------------------------

Nachdem wir unsere Unit-Tests kompiliert haben, müssen wir einen Weg finden, sie mit Maven auszuführen.

Durchführung unserer Einheitentests

Wir können unsere Unit-Tests mit dem Maven Surefire Plugin ausführen. Da wir sowohl „normale“ Unit-Tests als auch Unit-Tests ausführen möchten, die mit dem Spock Framework geschrieben wurden, müssen wir das Maven Surefire-Plug-in wie folgt konfigurieren:

  1. Alle Testklassen einbeziehen, deren Name mit der Zeichenfolge:'Test' endet. Dies sind "normale" Unit-Tests, die mit der Programmiersprache Java geschrieben werden.
  2. Alle Testklassen einbeziehen, deren Name mit der Zeichenfolge:'Spec' endet. Dies sind Komponententests, die mit dem Spock Framework und der Programmiersprache Groovy geschrieben werden.

Nachdem wir das Maven Surefire Plugin konfiguriert haben, werden die plugins Abschnitt unserer pom.xml Datei sieht wie folgt aus:

<plugins>
    <plugin>
        <groupId>org.codehaus.gmavenplus</groupId>
        <artifactId>gmavenplus-plugin</artifactId>
        <version>1.5</version>
        <executions>
            <execution>
                <goals>
                    <goal>addTestSources</goal>
                    <goal>testCompile</goal>
                </goals>
            </execution>
        </executions>
    </plugin>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.3</version>
        <configuration>
            <source>1.8</source>
            <target>1.8</target>
        </configuration>
    </plugin>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.18.1</version>
        <configuration>
            <includes>
                <include>**/*Test.java</include>
                <include>**/*Spec.java</include>
            </includes>
        </configuration>
    </plugin>
</plugins>

Wir können jetzt unsere Komponententests ausführen, indem wir den folgenden Befehl an der Eingabeaufforderung ausführen:

mvn clean test

Wenn wir dies tun, sehen wir, dass das Maven Surefire Plugin die Komponententests ausführt, die von diesen Testklassen gefunden werden:

  • Die net.petrikainulainen.spock.HelloSpec ist eine Testklasse, die Spock Framework verwendet.
  • Der net.petrikainulainen.spock.HelloTest ist eine "normale" Testklasse, die JUnit verwendet.

Der relevante Teil der Ausgabe sieht wie folgt aus:

> mvn clean test
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building Writing Unit Tests With Spock - Configuration 0.1
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-surefire-plugin:2.18.1:test (default-test) @ unit-testing-configuration ---
[INFO] Surefire report directory: /Users/loke/Projects/Java/Blog/spock-examples/unit-testing/configuration/target/surefire-reports

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running net.petrikainulainen.spock.HelloSpec
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.203 sec - in net.petrikainulainen.spock.HelloSpec
Running net.petrikainulainen.spock.HelloTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0 sec - in net.petrikainulainen.spock.HelloTest

Results :

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

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3.415 s
[INFO] Finished at: 2015-08-24T21:53:09+03:00
[INFO] Final Memory: 20M/219M
[INFO] ------------------------------------------------------------------------

Als letztes müssen wir Maven konfigurieren, um einen HTML-Testbericht zu erstellen, der die Testergebnisse von Komponententests beschreibt, die das Spock Framework verwenden.

Erstellen eines HTML-Testberichts

Wir können einen HTML-Testbericht erstellen, indem wir die Spock Reports-Erweiterung verwenden. Standardmäßig erstellt es einen HTML-Bericht für jede aufgerufene Spezifikation und eine Zusammenfassung, die alle aufgerufenen Spezifikationen auflistet.

Wir können diese Spock-Erweiterung verwenden, indem wir diesen Schritten folgen:

Zuerst , müssen wir das JCenter Maven-Repository von Bintray zu unserer pom.xml hinzufügen Datei. Nachdem wir das erledigt haben, werden die Repositories Abschnitt unserer pom.xml Datei sieht wie folgt aus:

<repositories>
    <repository>
        <id>jcenter</id>
        <name>JCenter Repo</name>
        <url>http://jcenter.bintray.com</url>
    </repository>
</repositories>

Zweiter , müssen wir das JAR der Spock Reports-Erweiterung zum Klassenpfad hinzufügen. Wir können dies tun, indem wir die spock-reports deklarieren Abhängigkeit (Version 1.2.7) in unserer pom.xml Datei. Nachdem wir das erledigt haben, werden die dependencies Abschnitt unserer pom.xml Datei sieht wie folgt aus:

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.spockframework</groupId>
        <artifactId>spock-core</artifactId>
        <version>1.0-groovy-2.4</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.codehaus.groovy</groupId>
        <artifactId>groovy-all</artifactId>
        <version>2.4.4</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>com.athaydes</groupId>
        <artifactId>spock-reports</artifactId>
        <version>1.2.7</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Dritter , da wir Maven verwenden, müssen wir das Ausgabeverzeichnis der Spock Reports Extension ändern. Der Grund dafür ist, dass das Standardausgabeverzeichnis build/spock-reports ist , und wir möchten, dass unser HTML-Testbericht zu den target/spock-reports erstellt wird Verzeichnis.

Wir können das Verhalten der Spock Reports-Erweiterung anpassen, indem wir eine Eigenschaftendatei an folgendem Speicherort (relativ zum Klassenpfad) erstellen:

META-INF/services/com.athaydes.spockframework.report.IReportCreator.properties

Wir können das Ausgabeverzeichnis ändern, indem wir diesen Schritten folgen:

  1. Holen Sie sich die Standardeigenschaftendatei.
  2. Kopieren Sie die Standardeigenschaftendatei nach src/test/resources/META-INF/services/ Verzeichnis.
  3. Legen Sie den Wert von com.athaydes.spockframework.report.outputDir fest -Eigenschaft auf target/spock-reports .

Der Inhalt unserer Properties-Datei sieht wie folgt aus:

# Name of the implementation class of the report creator
# Currently supported classes are:
#   1. com.athaydes.spockframework.report.internal.HtmlReportCreator
#   2. com.athaydes.spockframework.report.template.TemplateReportCreator
com.athaydes.spockframework.report.IReportCreator=com.athaydes.spockframework.report.internal.HtmlReportCreator

# Set properties of the report creator
# For the HtmlReportCreator, the only properties available are
# (the location of the css files is relative to the classpath):
com.athaydes.spockframework.report.internal.HtmlReportCreator.featureReportCss=spock-feature-report.css
com.athaydes.spockframework.report.internal.HtmlReportCreator.summaryReportCss=spock-summary-report.css
# exclude Specs Table of Contents
com.athaydes.spockframework.report.internal.HtmlReportCreator.excludeToc=false

# Output directory (where the spock reports will be created) - relative to working directory
com.athaydes.spockframework.report.outputDir=target/spock-reports

# If set to true, hides blocks which do not have any description
com.athaydes.spockframework.report.hideEmptyBlocks=false

Wir können jetzt unsere Komponententests mit dem folgenden Befehl ausführen:

mvn clean test

Wenn wir unsere Unit-Tests ausführen, sehen wir, dass die Spock Reports-Erweiterung initialisiert wird, bevor unsere Unit-Tests ausgeführt werden:

> mvn clean test

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Aug 24, 2015 10:41:41 PM org.codehaus.groovy.runtime.callsite.PojoMetaMethodSite$PojoCachedMethodSiteNoUnwrap invoke
INFO: Configuring com.athaydes.spockframework.report.SpockReportExtension
Aug 24, 2015 10:41:41 PM org.codehaus.groovy.runtime.callsite.PojoMetaMethodSite$PojoCachedMethodSiteNoUnwrap invoke
INFO: Trying to load custom configuration at file:/Users/loke/Projects/Java/Blog/spock-examples/unit-testing/configuration/target/test-classes/META-INF/services/com.athaydes.spockframework.report.IReportCreator.properties
Aug 24, 2015 10:41:41 PM org.codehaus.groovy.runtime.callsite.PojoMetaMethodSite$PojoCachedMethodSiteNoUnwrap invoke
INFO: SpockReports config loaded: [com.athaydes.spockframework.report.internal.HtmlReportCreator.excludeToc:false, com.athaydes.spockframework.report.template.TemplateReportCreator.reportFileExtension:md, com.athaydes.spockframework.report.template.TemplateReportCreator.specTemplateFile:/templateReportCreator/spec-template.md, com.athaydes.spockframework.report.IReportCreator:com.athaydes.spockframework.report.internal.HtmlReportCreator, com.athaydes.spockframework.report.template.TemplateReportCreator.summaryTemplateFile:/templateReportCreator/summary-template.md, com.athaydes.spockframework.report.internal.HtmlReportCreator.summaryReportCss:spock-summary-report.css, com.athaydes.spockframework.report.template.TemplateReportCreator.summaryFileName:summary.md, com.athaydes.spockframework.report.internal.HtmlReportCreator.featureReportCss:spock-feature-report.css, com.athaydes.spockframework.report.hideEmptyBlocks:false, com.athaydes.spockframework.report.outputDir:target/spock-reports]
Aug 24, 2015 10:41:41 PM org.codehaus.groovy.runtime.callsite.PojoMetaMethodSite$PojoCachedMethodSiteNoUnwrap invoke
INFO: Loading settings for reportCreator of type com.athaydes.spockframework.report.internal.HtmlReportCreator
Running net.petrikainulainen.spock.HelloSpec
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.229 sec - in net.petrikainulainen.spock.HelloSpec
Running net.petrikainulainen.spock.HelloTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.001 sec - in net.petrikainulainen.spock.HelloTest

Results :

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

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3.481 s
[INFO] Finished at: 2015-08-24T22:41:42+03:00
[INFO] Final Memory: 20M/218M
[INFO] ------------------------------------------------------------------------

Nachdem wir unsere Unit-Tests durchgeführt haben, können wir den erstellten HTML-Testbericht sehen, indem wir die index.html öffnen Datei gefunden aus den target/spock-reports Verzeichnis.

Fassen wir zusammen, was wir aus diesem Blogbeitrag gelernt haben.

Zusammenfassung

Dieser Blogbeitrag hat uns vier Dinge gelehrt:

  • Wir wissen, wie wir die erforderlichen Abhängigkeiten mit Maven erhalten können.
  • Wir können Groovy-Code kompilieren, indem wir das GMavenPlus-Plugin verwenden.
  • Wir können das Surefire Maven Plugin so konfigurieren, dass Komponententests ausgeführt werden, die das Spock Framework verwenden.
  • Wir können einen HTML-Testbericht erstellen, der die Testergebnisse von Komponententests enthält, die das Spock Framework verwenden, indem wir die Spock Reports-Erweiterung verwenden.

Der nächste Teil dieses Tutorials beschreibt, wie wir ein Gradle-Projekt erstellen können, das dieselben Anforderungen erfüllt wie unser Maven-Projekt.

P.S. Sie können die Beispielanwendung dieses Blogbeitrags von Github herunterladen.


Java-Tag