Come faccio ad avere la mia integrazione Maven test da eseguire

Question

Ho un progetto multi-modulo maven2 e in ciascuno dei miei moduli bambino ho test JUnit che sono denominati Test.java e Integration.java per i test unitari e test di integrazione, rispettivamente. Quando eseguo:

mvn test

tutti i test JUnit *Test.java all'interno dei moduli bambino vengono eseguite. Quando eseguo

mvn test -Dtest=**/*Integration

nessuno dei test Integration.java ottenere eseguire all'interno dei moduli bambino.

Queste sembrano esattamente lo stesso comando per me, ma quello con il -Dtest = / * Integrazione ** non funziona visualizza 0 test in esecuzione a livello genitore, che non ci sono eventuali test

Answer 1

È possibile impostare infallibile di Maven per eseguire unit test e test di integrazione separatamente. Nella fase di test di unità standard si esegue tutto ciò che non corrisponde a modello di un test di integrazione. È quindi crea una seconda fase di test che gestisce solo i test di integrazione.

Ecco un esempio:

    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-surefire-plugin</artifactId>
      <configuration>
        <excludes>
          <exclude>**/*IntegrationTest.java</exclude>
        </excludes>
      </configuration>
      <executions>
        <execution>
          <id>integration-test</id>
          <goals>
            <goal>test</goal>
          </goals>
          <phase>integration-test</phase>
          <configuration>
            <excludes>
              <exclude>none</exclude>
            </excludes>
            <includes>
              <include>**/*IntegrationTest.java</include>
            </includes>
          </configuration>
        </execution>
      </executions>
    </plugin>

Answer 2

Il Maven costruire ciclo di vita ora include la " integrazione-test" fase per l'esecuzione di test di integrazione, che vengono eseguiti separatamente dai test di unità eseguite durante la 'fase di test'. Si corre dietro "pacchetto", quindi se si esegue "mvn verificare", "mvn install", o "mvn distribuire", test di integrazione saranno eseguiti lungo la strada.

Per impostazione predefinita, l'integrazione-test viene eseguito classi di test denominati **/IT*.java, **/*IT.java e **/*ITCase.java, ma questo può essere configurata.

Per ulteriori informazioni su come collegare questo tutto in su, vedere la fail-safe plug-in , il fail-safe pagina di utilizzo (non collegata correttamente dalla pagina precedente mentre scrivo questo), e anche verificare questo Sonatype post del blog .

Answer 3

Ho fatto esattamente quello che si vuole fare e funziona benissimo. Prove di unità "* Test" vengono sempre eseguiti, e "* IntegrationTests" eseguiti solo quando si esegue un mvn verificare o mvn install. Qui il frammento dal mio POM. serg10 quasi aveva ragione .... ma non del tutto.

  <plugin>
    <!-- Separates the unit tests from the integration tests. -->
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <configuration>
       <!-- Skip the default running of this plug-in (or everything is run twice...see below) -->
       <skip>true</skip>
       <!-- Show 100% of the lines from the stack trace (doesn't work) -->
       <trimStackTrace>false</trimStackTrace>
    </configuration>
    <executions>
       <execution>
          <id>unit-tests</id>
          <phase>test</phase>
          <goals>
             <goal>test</goal>
          </goals>
          <configuration>
                <!-- Never skip running the tests when the test phase is invoked -->
                <skip>false</skip>
             <includes>
                   <!-- Include unit tests within integration-test phase. -->
                <include>**/*Tests.java</include>
             </includes>
             <excludes>
               <!-- Exclude integration tests within (unit) test phase. -->
                <exclude>**/*IntegrationTests.java</exclude>
            </excludes>
          </configuration>
       </execution>
       <execution>
          <id>integration-tests</id>
          <phase>integration-test</phase>
          <goals>
             <goal>test</goal>
          </goals>
          <configuration>
            <!-- Never skip running the tests when the integration-test phase is invoked -->
             <skip>false</skip>
             <includes>
               <!-- Include integration tests within integration-test phase. -->
               <include>**/*IntegrationTests.java</include>
             </includes>
          </configuration>
       </execution>
    </executions>
  </plugin>

In bocca al lupo!

Answer 4

Si possono dividere molto facilmente usando categorie JUnit e Maven.
Questo è mostrato molto, molto brevemente qui di seguito per i test unitari e di integrazione scissione.

Definisci un indicatore di interfaccia

Il primo passo per raggruppare un test utilizzando categorie è quello di creare un'interfaccia marcatore.
Questa interfaccia verrà utilizzato per contrassegnare tutti i test che si desidera essere eseguito come test di integrazione.

public interface IntegrationTest {}

Mark vostre classi di test

Aggiungi la categoria di annotazione alla parte superiore della vostra classe di test. Prende il nome della nuova interfaccia.

import org.junit.experimental.categories.Category;

@Category(IntegrationTest.class)
public class ExampleIntegrationTest{

    @Test
    public void longRunningServiceTest() throws Exception {
    }

}

Configurazione Maven unit test

La bellezza di questa soluzione è che nulla cambia davvero per il lato unit test delle cose.
Aggiungiamo semplicemente un po 'di configurazione per il plugin Maven infallibile per rendere più ignorare eventuali test di integrazione
.

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.11</version>
    <configuration>
        <includes>
            <include>**/*.class</include>
        </includes>
        <excludedGroups>
            com.test.annotation.type.IntegrationTest
        </excludedGroups>
    </configuration>
</plugin>

Quando si esegue un mvn clean test, solo il test di unità non marcate verrà eseguito.

Configura Maven Integrazione Test

Anche in questo caso la configurazione per questo è molto semplice.
Usiamo il plugin fail-safe di serie e configurarlo per eseguire solo i test di integrazione.

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-failsafe-plugin</artifactId>
    <version>2.19.1</version>
    <configuration>
        <includes>
            <include>**/*.class</include>
        </includes>
        <groups>
            com.test.annotation.type.IntegrationTest
        </groups>
    </configuration>
</plugin>

La configurazione utilizza un obiettivo esecuzione standard per eseguire il plugin fail-safe durante la fase di integrazione-test della build.

È ora possibile fare un mvn clean install.
Questo tempo così come i test di unità in esecuzione, i test di integrazione vengono eseguiti durante la fase di integrazione-test.

Answer 5

Si dovrebbe provare a utilizzare esperto di fail-safe plug . Si può dire che per includere un certo insieme di test.

Answer 6

Per impostazione predefinita, Maven funziona solo test che hanno prova da qualche parte nel nome della classe.

Rinomina per IntegrationTest ed è probabilmente il lavoro.

In alternativa è possibile modificare la configurazione di Maven per includere il file, ma è probabilmente più facile e migliore, solo per citarne i test SomethingTest.

inclusioni ed esclusioni di test :

  

Per impostazione predefinita, il plugin sarà Surefire   includere automaticamente tutte le classi di test   con i seguenti caratteri jolly:

     

  
• "** / Test * .java" - include tutta la sua sottodirectory e tutti java   nomi di file che iniziano con "test".
  
• "** / * Test.java" - include tutta la sua sottodirectory e tutti java   nomi di file che terminano con "Test".
  
• "** / * TestCase.java" - include tutta la sua sottodirectory e tutti java   nomi di file che terminano con "TestCase".
  

     

Se le classi di test non va con   la convenzione di denominazione, quindi configurare   Plugin Surefire e specificare i test   si desidera includere.

Answer 7

Un altro modo di gestire i test di integrazione con Maven è quello di utilizzare la funzione di profilo:

...
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <configuration>
                <includes>
                    <include>**/*Test.java</include>
                </includes>
                <excludes>
                    <exclude>**/*IntegrationTest.java</exclude>
                </excludes>
            </configuration>
        </plugin>
    </plugins>
</build>

<profiles>
    <profile>
        <id>integration-tests</id>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <configuration>
                        <includes>
                            <include>**/*IntegrationTest.java</include>
                        </includes>
                        <excludes>
                            <exclude>**/*StagingIntegrationTest.java</exclude>
                        </excludes>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>
...

Esecuzione di 'mvn clean install' verrà eseguito la compilazione di default. Come specificato in precedenza i test di integrazione saranno ignorati. Esecuzione di 'mvn clean install -P integrazione-test' includerà i test di integrazione (ho anche ignorare il mio test di integrazione messa in scena). Inoltre, ho un server CI che corre i miei test di integrazione ogni notte e per questo ho eseguire il comando 'integrazione-test di prova mvn -p' .

Answer 8

È possibile seguire il Maven documentazione per eseguire i test di unità con la compilazione ed eseguire i test di integrazione separatamente.

<project>
    <properties>
        <skipTests>true</skipTests>
    </properties>
    [...]
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-failsafe-plugin</artifactId>
                <version>2.20.1</version>
                <configuration>
                    <skipITs>${skipTests}</skipITs>
                </configuration>
            </plugin>
        </plugins>
    </build>
    [...]
</project>

Questo vi permetterà di eseguire tutti i test di integrazione disabilitato per impostazione predefinita. Per eseguire loro, si utilizza questo comando:

mvn install -DskipTests=false