Esecuzione di test unitari spock con Maven

Question

Esecuzione di test unitari spock con Maven

In un progetto precedente ho usato il framework di test Spock per testare il mio codice Java. Ho trovato questo davvero produttivo, quindi sto cercando di aggiungere test Spock al mio progetto attuale che utilizza Maven come strumento di compilazione (il progetto precedente usava Gradle). Mentre posso ottenere Maven per compilare i miei test Spock (usando groovy-eclipse-compiler), non sono in grado di ottenere Maven per eseguire i test.

Ho fatto un semplice esempio per dimostrare il mio problema con 2 file:

pom.xml
src/test/java/ASpec.groovy

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

Contenuto di ASpec.groovy:

import spock.lang.Specification

class ASpec extends Specification {

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

Quando eseguo mvn clean test (o mvn clean install) mi aspetto che il mio test di unità singola venga eseguito e fallisca. Mentre è compilato, Maven non lo esegue. Qualcuno sa come eseguire un test di unità Spock da Maven (o se è possibile?)

, non ho messo il mio test in un pacchetto per mantenere l'esempio semplice. Inoltre ho inserito il mio codice groovy src / test / java per evitare di configurare l'esempio per raccogliere i file sorgente da una directory aggiuntiva, di nuovo per mantenere l'esempio il più semplice possibile.)

19

Italian java maven unit-testing groovy spock

Author: mkobit, 2014-08-07

Source

3 answers

Questa risposta è puramente supplementare alla risposta di @PeterNiederwieser. In esso menziona che è possibile configurare il modello di nome utilizzato da Surefire. Ecco un esempio di ciò che ha funzionato per me:

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

Fonte

Come ho detto nei commenti, non sono sicuro del motivo per cui **/*Spec.groovy non ha funzionato, ma sono felice di essere in grado di utilizzare la normale convenzione Spock qui.

21

Author: mnd, 2015-08-19 20:34:41

Avevo lo stesso requisito per aggiungere Spock alla mia app web java esistente. Ho provato Peters ma non ha funzionato per me. gmavenplus-plugin in qualche modo (nessuna idea) ha sostituito la mia dipendenza da guava con una vecchia google lib e la mia applicazione Spring si è rotta lamentandosi di un metodo inesistente.

Dopo letteralmente forse 2 o 3 dozzine di tentativi, finalmente sono stato in grado di integrare i miei test unitari Spock e test di integrazione e, cosa più importante, di isolare la compilazione di Spock groovy classi dalla mia applicazione Java/Junit Spring/Hibernate esistente.

Naturalmente se avessi gradle avrebbe risolto il problema...ma questo è un progetto legacy e quindi non ho avuto la scelta.

Di seguito sono riportati i plugin che ho aggiunto. Si prega di notare che i test unitari Spock terminano con le specifiche. I test di integrazione Spock terminano con ESSO (ma molto probabilmente dovrebbero essere SpecIT). Ho messo i miei test Spock sotto 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>

E qui ci sono le mie dipendenze:

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

E solo per farvi sappi, il mio POM originale non aveva assolutamente alcun plugin esplicito. Quindi ho avuto un POM molto semplice per il mio progetto. Quindi, dovrebbe funzionare per te. È un progetto Java 1.7.

...e infine, solo per darti una certa sicurezza che questo non è un post spazzatura, ho fatto più test per garantire che quanto sopra funzionasse:

Basta costruire la guerra senza i test e distribuire e fumare testarlo localmente
installazione pulita mvn-DskipTests - Dmaven.test.skip=vero
Fare un test compilare e vedere se i test unitari Groovy vengono compilati pure
mvn - X clean test-compile
Fai un'installazione pulita senza il test di integrazione (mi sono assicurato che non funzionasse per questo test) e vedi se vengono eseguiti i test di unità Groovy
installazione pulita mvn-DskipITs
Basta eseguire il test di integrazione
nv failsafe: test di integrazione

Mi sarebbe piaciuto includere screenshot di quanto sopra come prova, ma avrebbe dovuto essere censored...So, Spero sinceramente che questo ti aiuti, come stavo andando mentale cercando di ottenere questo lavoro...Maven è un'enorme area tematica. Buona fortuna:=)

0

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

score 20 · Accepted Answer

Maven Surefire trova le classi di test con il loro nome. Modificare il nome della classe in ATest o riconfigurare il modello di nome utilizzato da Surefire. Il POM per il progetto spock-example dimostra come fare quest'ultimo.