Come fermare Maven di verificare fase di ricostruzione del manufatto?

StackOverflow https://stackoverflow.com/questions/4330518

Domanda

Immaginate un progetto Java costruito utilizzando Maven per il quale ho:

  • alcuni test di unità in rapida esecuzione che:
    • sviluppatori dovrebbe essere eseguito prima di impegnarsi
    • il mio server CI (Hudson, FWIW) dovrebbe essere eseguito su di rilevamento di un nuovo commit, dando un feedback quasi istantaneo in caso di guasti
  • alcuni test lenta esecuzione di accettazione automatizzati che:
    • sviluppatori può funzionare se lo desiderano, per esempio di riprodurre e fallimenti fix
    • il mio server CI dovrebbe essere eseguito dopo l'esecuzione con successo i test di unità

Questo mi sembra uno scenario tipico. Attualmente, sto correndo:

  • i test di unità in fase di "test"
  • le prove di accettazione in fase di "verificare"

Ci sono due posti di lavoro CI configurati, sia che punta al ramo VCS del progetto:

  1. "Commit Stage", che corre "pacchetto mvn" (compilazione e unit test del codice, costruire il manufatto), che in caso di successo, trigger:
  2. "test automatizzati di accettazione", che corre "mvn verificare" (istituito, corsa, e abbattere le prove di collaudo)

Il problema è che i test di unità di lavoro 2 e costruisce l'artefatto sotto test di nuovo (perché la fase di verifica richiama automaticamente la fase di pacchetto). Questo è indesiderabile per motivi diversi (discendente importanza):

  • l'artefatto creato da lavoro 2 non può essere identico a quello creato da lavoro 1 (ad esempio, se v'è stato un nuovo commit nel frattempo)
  • allunga il ciclo di feedback per lo sviluppatore che ha fatto il commit (cioè vuole più tempo per loro di scoprire hanno rotto la build)
  • spreca risorse sul server CI

Quindi la mia domanda è, come posso configurare lavoro 2 per utilizzare l'artefatto creato da lavoro 1?

Mi rendo conto che potrei semplicemente avere un lavoro CI che corre "MVN verificare", che creerebbe l'artefatto solo una volta, ma voglio avere i posti di lavoro CI separati sopra descritte al fine di attuare una distribuzione in stile Farley conduttura.

In caso aiuta nessuno, ecco la piena Maven 2 POM del "Progetto 2" nella risposta accettata: 

<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>com.example.cake</groupId>
    <artifactId>cake-acceptance</artifactId>
    <version>1.0</version>
    <packaging>jar</packaging>
    <name>Cake Shop Acceptance Tests</name>
    <description>
        Runs the automated acceptance tests for the Cake Shop web application.
    </description>
    <build>
        <plugins>
            <!-- Compiler -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
            <!-- Suppress the normal "test" phase; there's no unit tests -->
            <plugin>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.5</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
            <!-- Cargo (starts and stops the web container) -->
            <plugin>
                <groupId>org.codehaus.cargo</groupId>
                <artifactId>cargo-maven2-plugin</artifactId>
                <version>1.0.5</version>
                <executions>
                    <execution>
                        <id>start-container</id>
                        <phase>pre-integration-test</phase>
                        <goals>
                            <goal>start</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>stop-container</id>
                        <phase>post-integration-test</phase>
                        <goals>
                            <goal>stop</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <!-- Don't wait for CTRL-C after starting the container -->
                    <wait>false</wait>

                    <container>
                        <containerId>jetty7x</containerId>
                        <type>embedded</type>
                        <timeout>20000</timeout>
                    </container>

                    <configuration>
                        <properties>
                            <cargo.servlet.port>${http.port}</cargo.servlet.port>
                        </properties>
                        <deployables>
                            <deployable>
                                <groupId>${project.groupId}</groupId>
                                <artifactId>${target.artifactId}</artifactId>
                                <type>war</type>
                                <properties>
                                    <context>${context.path}</context>
                                </properties>
                            </deployable>
                        </deployables>
                    </configuration>
                </configuration>
            </plugin>
            <!-- Failsafe (runs the acceptance tests) -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-failsafe-plugin</artifactId>
                <version>2.6</version>
                <executions>
                    <execution>
                        <id>integration-test</id>
                        <goals>
                            <goal>integration-test</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>verify</id>
                        <goals>
                            <goal>verify</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <includes>
                        <include>**/*Test.java</include>
                    </includes>
                    <skipTests>false</skipTests>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <dependencies>
            <!-- Add your tests' dependencies here, e.g. Selenium or Sahi,
                with "test" scope -->
        <dependency>
            <!-- The artifact under test -->
            <groupId>${project.groupId}</groupId>
            <artifactId>${target.artifactId}</artifactId>
            <version>${target.version}</version>
            <type>war</type>
        </dependency>
    </dependencies>
    <properties>
        <!-- The artifact under test -->
        <target.artifactId>cake</target.artifactId>
        <target.version>0.1.0-SNAPSHOT</target.version>
        <context.path>${target.artifactId}</context.path>
        <http.port>8081</http.port>
        <java.version>1.6</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
</project>

Si noti che anche se questo progetto "test" non crea un artefatto, è di utilizzare un qualche tipo di imballaggio (io ho usato "jar" qui), altrimenti non test vengono eseguiti in fase di verifica.

È stato utile?

Soluzione

Prova due Maven progetti. Il primo contiene i test di compilazione e di unità. Si installa i manufatti nel repository locale. Il secondo lavoro viene eseguito il secondo progetto Maven che dichiara i manufatti del primo progetto come dipendenze ed esegue i test funzionali.

Non sono sicuro se lo scenario che ho appena descritto è possibile, ma penso che sia.

Per una rapida miglioramento si può ignorare il test di unità con -Dmaven.test.skip=true. Se si passa il numero di revisione del codice nel tuo SCM per il secondo lavoro, si dovrebbe essere in grado di checkout lo stesso codice sorgente.

Si può anche verificare in plug-clone di lavoro SCM. Questo potrebbe offrire alcune opzioni aggiuntive.

Altri suggerimenti

Lo so che è passato molto tempo, ma questo è ben indicizzato e nessuna delle risposte fare quello che è stato chiesto, ma ho trovato qualcosa che funziona: 

mvn failsafe:integration-test

Questa esegue i test direttamente, senza passare attraverso tutti i passaggi intermedi di costruzione del progetto. Si consiglia di aggiungere failsafe:verify dopo di esso.

  

Quindi la mia domanda è, come posso configurare   lavoro 2 per usare l'artefatto creato da   lavoro 1?

Non è possibile.

Non è necessario. Il Maven Corporatura ciclo di vita è configurato in modo che i suoni come se soddisferà le vostre esigenze. Il ciclo di vita di test verrà eseguito solo i junits veloci. Pacchetto costruire il tuo stato finale senza correre la verifica.

Hai solo bisogno di un posto di lavoro CI. Quando il CI esegue il deploy del Maven / installare il ciclo di vita, se le junits falliscono la compilazione fallisce, gli script di verifica non verranno eseguiti.

È possibile definire un profilo di Maven che verrà utilizzato per eseguire solo i test di integrazione. Lo faccio molto.

Qualcosa di simile a questo: 

<profiles>
    <profile>
        <id>integration</id>
        <activation>
            <activeByDefault>false</activeByDefault>
        </activation>
        <build>
            <plugins>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId><version>2.17</version>
                    <configuration>
                        <skipTests>true</skipTests>
                    </configuration>
                </plugin>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId><version>2.4</version>
                    <configuration>
                        <outputDirectory>/tmp</outputDirectory>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>

Si potrebbe richiamare questo con: 

mvn verify -Pintegration

Purtroppo il plugin guerra non può essere saltato, ma è possibile inviare la sua uscita da qualche parte fuori del modo (ho usato / tmp). Se si vuole veramente risparmiare millisecondi, si potrebbe anche rendere più ignorare le risorse web (tranne web.xml, non funzionerà senza quella).

È anche possibile utilizzare il profilo di saltare qualsiasi altro plugin che si potrebbe essere in esecuzione, ad esempio, il plug-in assemblea, Cobertura, PMD, ecc.

profilo Maven che esegue solo i test di integrazione ( come suggerito qui ) non è sufficiente. È inoltre necessario assicurarsi che la configurazione di -compilatore Maven-plugin ha useIncrementalCompilation = false . L'esecuzione del profilo in questo modo, non sarà automaticamente ri-compilazione, per esempio:. 

<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>
        <useIncrementalCompilation>false</useIncrementalCompilation>
    </configuration>
</plugin>
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top