web-dev-qa-db-fra.com

Exécution de tests unitaires Spock avec Maven

Sur un projet précédent, j'ai utilisé le framework de test Spock pour tester mon code Java. J’ai trouvé cela très productif et j’essaie d’ajouter des tests Spock à mon projet actuel, qui utilise Maven comme outil de construction (le projet précédent utilisait Gradle). Bien que Maven puisse compiler mes tests Spock (avec groovy-Eclipse-compiler), je ne parviens pas à le faire exécuter par Maven. 

J'ai créé un exemple simple pour illustrer mon problème avec 2 fichiers:

  • pom.xml
  • src/test/Java/ASpec.groovy

Contenu de pom.xml:

<project xmlns="http://maven.Apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.Apache.org/POM/4.0.0 http://maven.Apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>my.group</groupId>
    <artifactId>my-artifact</artifactId>
    <version>0.1-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
            <dependency>
            <groupId>org.codehaus.groovy</groupId>
            <artifactId>groovy-all</artifactId>
            <version>2.0.8</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.spockframework</groupId>
            <artifactId>spock-core</artifactId>
            <version>0.7-groovy-2.0</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.Apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <compilerId>groovy-Eclipse-compiler</compilerId>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>org.codehaus.groovy</groupId>
                        <artifactId>groovy-Eclipse-compiler</artifactId>
                        <version>2.8.0-01</version>
                    </dependency>
                    <dependency>
                        <groupId>org.codehaus.groovy</groupId>
                        <artifactId>groovy-Eclipse-batch</artifactId>
                        <version>2.1.8-01</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>
</project>

Contenu de ASpec.groovy:

import spock.lang.Specification

class ASpec extends Specification {

    def "Test A"(){
        // Always fail
        expect: false
    }
}

Lorsque j'exécute mvn clean test (ou mvn clean install), je m'attendrais à ce que mon test à unité unique soit exécuté et échoue. Même s'il est compilé, Maven ne l'exécute pas. Est-ce que quelqu'un sait comment exécuter un test unitaire Spock de Maven (ou si c'est possible?)

(Je n'ai pas mis mon test dans un paquet pour garder l'exemple simple. J'ai aussi placé mon code groovy dans src/test/Java pour éviter de configurer l'exemple pour extraire les fichiers source d'un répertoire supplémentaire, de nouveau pour conserver l'exemple simple que possible.)

javaunit-testingmavengroovyspock
19
Neil Stevens

Maven Surefire trouve les classes de test par leur nom. Changez le nom de la classe en ATest ou reconfigurez le modèle de nom utilisé par Surefire. Le POM pour le projet spock-example montre comment faire ce dernier.

20
Peter Niederwieser

Cette réponse est purement complémentaire à celle de @ PeterNiederwieser. Dans ce document, il mentionne que vous pouvez configurer le modèle de nom utilisé par Surefire. Voici un exemple de ce qui a fonctionné pour moi:

<plugin>
    <groupId>org.Apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.18</version>
    <configuration>
        <includes>
            <!-- By default only files ending in 'Test' will be included, so also include support for Spock style naming convention -->
            <!-- Oddly enough for Groovy files, *Spec.groovy does not work, but *Spec.Java does -->
            <include>**/*Test.Java</include>
            <include>**/*Spec.Java</include>
        </includes>
    </configuration>
</plugin>

La source

Comme je l'ai mentionné dans les commentaires, je ne sais pas pourquoi **/*Spec.groovy n'a pas fonctionné, mais je suis heureux de pouvoir utiliser la convention Spock normale ici.

21
mnd

J'avais la même exigence d'ajouter Spock à mon application Web Java existante .. J'ai essayé Peters mais cela n'a pas fonctionné pour moi. gmavenplus-plugin en quelque sorte (aucune idée) a remplacé ma dépendance à la goyave par une très ancienne librairie Google et mon application Spring a éclaté en se plaignant d'une méthode inexistante.

Après deux ou trois douzaines de tentatives, j'ai finalement réussi à intégrer mes tests unitaires Spock et d'intégration, et plus important encore, à isoler la compilation des classes groovy de Spock de mon application existante Java/Junit Spring/Hibernate.

Bien sûr, si j'avais eu le grade, cela aurait résolu le problème ... mais il s'agit d'un projet hérité et je n'avais donc pas le choix.

Ci-dessous se trouvent les plugins que j’ai ajoutés. Veuillez noter que les tests unitaires Spock se terminent par Spec . Les tests d’intégration Spock se terminent par IT (mais devrait probablement être SpecIT) . Je mets mes tests Spock sous src/test/groovy.

         <plugins>
            <plugin>
                <groupId>org.codehaus.gmavenplus</groupId>
                <artifactId>gmavenplus-plugin</artifactId>
                <version>1.4</version>
                <executions>
                    <execution>
                        <!-- Without joint compilation - no dependencies between Java and Groovy (inheritance)-->
                        <goals>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <sources>
                        <source>
                            <directory>${project.basedir}/src/main/Java/groovy</directory>
                            <includes>
                                <include>**/*.groovy</include>
                            </includes>
                        </source>
                    </sources>
                    <testSources>
                        <testSource>
                            <directory>${project.basedir}/src/test/groovy</directory>
                            <includes>
                                <include>**/*.groovy</include>
                            </includes>
                        </testSource>
                    </testSources>

                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.18.1</version>
                <configuration>
                    <testSourceDirectory>src/test/groovy</testSourceDirectory>
                    <testSourceDirectory>src/test/Java</testSourceDirectory>
                    <includes>
                        <include>**/*Spec.Java</include>
                        <!-- Yes, .Java extension -->
                        <include>**/*Test.Java</include>
                        <!-- Just in case having "normal" JUnit tests -->
                    </includes>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.Apache.maven.plugins</groupId>
                <artifactId>maven-failsafe-plugin</artifactId>
                <version>2.20</version>
                <configuration>
                    <useFile>false</useFile>
                    <includes>
                        <include>**/*IT.Java</include>
                    </includes>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>integration-test</goal>
                            <goal>verify</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>

Et voici mes dépendances:

        <!--Spock -->
        <dependency>
            <groupId>org.codehaus.groovy</groupId>
            <artifactId>groovy</artifactId>
            <version>2.4.7</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.spockframework</groupId>
            <artifactId>spock-core</artifactId>
            <version>1.1-groovy-2.4</version>
        </dependency>

        <dependency>
            <groupId>org.spockframework</groupId>
            <artifactId>spock-spring</artifactId>
            <version>1.1-groovy-2.4</version>
        </dependency>

        <dependency>
            <groupId>org.codehaus.groovy.modules.http-builder</groupId>
            <artifactId>http-builder</artifactId>
            <version>0.7.1</version>
        </dependency>
        <!--Spock mocking dependencies -->
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib-nodep</artifactId>
            <version>3.2.5</version>
        </dependency>
        <dependency>
            <groupId>org.objenesis</groupId>
            <artifactId>objenesis</artifactId>
            <version>2.6</version>
        </dependency>

Et juste pour vous faire savoir, mon POM d'origine n'avait absolument aucun plugin explicite AT ALL. J'ai donc eu un POM très simplement pour mon projet. Donc, il devrait fonctionner pour vous… .. Il s’agit d’un projet Java 1.7.

... et enfin, juste pour vous donner une certitude que ce n'est pas un poste de déchets, j'ai fait plusieurs tests afin de garantir le bon fonctionnement de ce qui précède:

  1. Il suffit de construire le WAR sans les tests, de déployer et de tester la fumée localement
    mvn installation propre -DskipTests -Dmaven.test.skip = true

  2. Faites un test de compilation et voyez si les tests de Groovy Unit sont également compilés.
    mvn -X test-compilation propre

  3. Effectuez une nouvelle installation sans le test d'intégration (je me suis assuré qu'il échouait pour ce test) et voyais si les tests de l'unité Groovy étaient exécutés.
    mvn installation propre -DskipITs

  4. Il suffit de lancer le test d'intégration
    mvn Failafe: integration-test

J'aurais aimé inclure des captures d'écran de ce qui précède comme preuve, mais il aurait fallu la censurer ... Alors, j'espère sincèrement que cela vous aide, car je devenais fou d'essayer de faire fonctionner cela ... Maven est un sujet énorme. surface. Bonne chance: =) 

1
Beezer