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 vraiment productif, j'essaie donc d'ajouter des tests Spock à mon projet actuel qui utilise Maven comme outil de construction (le projet précédent utilisait Gradle). Bien que je puisse obtenir Maven pour compiler mes tests Spock (en utilisant groovy-eclipse-compiler), je ne parviens pas à obtenir Maven pour exécuter les tests.

J'ai fait un exemple simple pour démontrer 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 unitaire unique soit exécuté et échoue. Pendant qu'il est compilé, Maven ne l'exécute pas. Quelqu'un sait-il comment exécuter un test unitaire Spock à partir de Maven (ou si c'est possible?)

(je n'ai pas mis mon test dans un paquet pour garder l'exemple simple. J'ai également mis mon code groovy src / test / java pour éviter de configurer l'exemple pour récupérer les fichiers source d'un répertoire supplémentaire, encore une fois pour garder l'exemple aussi simple que possible.)

Author: mkobit, 2014-08-07

3 answers

Maven Surefire trouve les classes de test par leur nom. Modifiez 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
Author: Peter Niederwieser, 2014-08-07 15:23:06

Cette réponse est purement complémentaire à la réponse de @PeterNiederwieser. Il y 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>

Source

Comme je le mentionne 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
Author: mnd, 2015-08-19 20:34:41

J'avais la même exigence pour 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 bibliothèque Google et mon application Spring s'est cassée en se plaignant d'une méthode inexistante.

Après littéralement peut-être 2 ou 3 douzaines de tentatives, j'ai finalement pu intégrer mes tests unitaires Spock, et des tests d'intégration et surtout isoler la compilation du Spock groovy classes de mon application Java/Junit Spring/Hibernate existante.

Bien sûr, si j'avais gradle il aurait résolu le problème...mais c'est un projet hérité et je n'avais donc pas le choix.

Voici 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 CELUI-ci (mais devraient très probablement être spéciques). J'ai mis 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 sachez que mon POM d'origine n'avait absolument aucun plug-in explicite. J'ai donc eu un POM très simple pour mon projet. Donc, il devrait - travailler pour vous. C'est un projet Java 1.7.

...et enfin, juste pour vous donner une certaine confiance que ce n'est pas un poste de déchets, j'ai fait plusieurs tests afin de m'assurer que ce qui précède a fonctionné:

  1. Construisez simplement la GUERRE sans les tests et déployez la et fumez la testez localement
    installation propre mvn-DskipTests - Dmaven.test.skip=true

  2. Faites un test compilez et voyez si les tests unitaires Groovy sont également compilés
    test de nettoyage mvn-X-compiler

  3. Faites une installation propre sans le test d'intégration (je me suis assuré qu'il échouait pour ce test) et voyez si les tests unitaires Groovy sont exécutés
    installation propre mvn-DskipITs

  4. Il suffit d'exécuter le test d'intégration
    mvn sécurité intégrée: test d'intégration

J'aurais aimé inclure des captures d'écran de ce qui précède comme preuve mais cela aurait dû être censored...So, J'espère sincèrement que cela vous aide, car j'allais essayer mentalement de faire fonctionner cela...Maven est un vaste domaine. Bonne chance:=)

 0
Author: Beezer, 2017-08-31 15:06:34