Comment exécuter mes tests d'intégration Maven

J'ai un projet multi-module maven2 et dans chacun de mes modules enfants j'ai des tests JUnit qui sont nommés Test.javaet Integration.javapour les tests unitaires et les tests d'intégration respectivement. Quand j'exécute:

mvn test

tous les tests JUnit *Test.javades modules enfants sont exécutés. Quand j'exécute

mvn test -Dtest=**/*Integration

aucun des Integration.javatests n'est exécuté dans les modules enfants.

Celles-ci me semblent être exactement la même commande mais celle avec -Dtest = / * Integration ** ne fonctionne pas, elle affiche 0 test en cours d'exécution au niveau parent, il n'y a pas de tests

Vous pouvez configurer Surefire de Maven pour exécuter des tests unitaires et des tests d'intégration séparément. Dans la phase de test unitaire standard, vous exécutez tout ce qui ne correspond pas à un test d'intégration. Vous créez ensuite une deuxième phase de test qui exécute uniquement les tests d'intégration.

Voici un exemple:

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

Le cycle de vie des builds Maven inclut désormais la phase de «test d'intégration» pour l'exécution des tests d'intégration, qui sont exécutés séparément des tests unitaires exécutés pendant la phase de «test». Il s'exécute après "package", donc si vous exécutez "mvn verify", "mvn install" ou "mvn deploy", des tests d'intégration seront exécutés en cours de route.

Par défaut, l' intégration test exécute les classes de test nommés **/IT*.java, **/*IT.javaet **/*ITCase.java, mais cela peut être configuré.

Pour plus de détails sur la façon de câbler tout cela, consultez le plugin Failsafe , la page d'utilisation Failsafe (pas correctement liée à la page précédente au moment où j'écris ceci), et consultez également ce billet de blog Sonatype .

J'ai fait EXACTEMENT ce que vous vouliez faire et cela fonctionne très bien. Les tests unitaires "* Tests" sont toujours exécutés et "* IntegrationTests" ne s'exécutent que lorsque vous effectuez une vérification mvn ou une installation mvn. Voici l'extrait de mon POM. serg10 avait presque raison ... mais pas tout à fait.

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

Bonne chance!

Vous pouvez les diviser très facilement en utilisant les catégories JUnit et Maven.
Ceci est montré très, très brièvement ci-dessous par des tests unitaires et d'intégration.

Définir une interface de marqueur

La première étape du regroupement d'un test à l'aide de catégories consiste à créer une interface de marqueurs.
Cette interface sera utilisée pour marquer tous les tests que vous souhaitez exécuter comme tests d'intégration.

public interface IntegrationTest {}

Marquez vos classes de test

Ajoutez l'annotation de catégorie en haut de votre classe de test. Il prend le nom de votre nouvelle interface.

import org.junit.experimental.categories.Category;

@Category(IntegrationTest.class)
public class ExampleIntegrationTest{

    @Test
    public void longRunningServiceTest() throws Exception {
    }

}

Configurer les tests unitaires Maven

La beauté de cette solution est que rien ne change vraiment pour le côté test unitaire des choses.
Nous ajoutons simplement une configuration au plugin maven surefire pour qu'il ignore les tests d'intégration.

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

Lorsque vous effectuez un mvn clean test, seuls vos tests unitaires non marqués seront exécutés.

Configurer les tests d'intégration Maven

Là encore, la configuration est très simple.
Nous utilisons le plugin de sécurité standard et le configurons pour exécuter uniquement les tests d'intégration.

<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 configuration utilise un objectif d'exécution standard pour exécuter le plug-in de sécurité pendant la phase de test d'intégration de la construction.

Vous pouvez maintenant faire un mvn clean install.
Cette fois-ci, ainsi que les tests unitaires en cours d'exécution, les tests d'intégration sont exécutés pendant la phase de test d'intégration.

Vous devriez essayer d'utiliser le plugin de sécurité maven . Vous pouvez lui dire d'inclure un certain ensemble de tests.

Par défaut, Maven exécute uniquement les tests qui ont Test quelque part dans le nom de la classe.

Renommez en IntegrationTest et cela fonctionnera probablement.

Vous pouvez également modifier la configuration de Maven pour inclure ce fichier, mais il est probablement plus facile et préférable de nommer vos tests SomethingTest.

Des inclusions et exclusions de tests :

Par défaut, le plug-in Surefire inclura automatiquement toutes les classes de test avec les modèles de caractères génériques suivants:

• \*\*/Test\*.java - inclut tous ses sous-répertoires et tous les noms de fichiers java commençant par "Test".
• \*\*/\*Test.java - inclut tous ses sous-répertoires et tous les noms de fichiers java qui se terminent par "Test".
• \*\*/\*TestCase.java - inclut tous ses sous-répertoires et tous les noms de fichiers java qui se terminent par "TestCase".

Si les classes de test ne sont pas conformes à la convention de dénomination, configurez le plug-in Surefire et spécifiez les tests que vous souhaitez inclure.

Une autre façon d'exécuter des tests d'intégration avec Maven consiste à utiliser la fonction de profil:

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

L'exécution de 'mvn clean install' exécutera la construction par défaut. Comme spécifié ci-dessus, les tests d'intégration seront ignorés. L'exécution de 'mvn clean install -P integration-tests' inclura les tests d'intégration ( j'ignore également mes tests d'intégration de staging). De plus, j'ai un serveur CI qui exécute mes tests d'intégration tous les soirs et pour cela j'émets la commande 'mvn test -P integration-tests' .

Vous pouvez suivre la documentation de maven pour exécuter les tests unitaires avec la version et exécuter les tests d'intégration séparément.

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

Cela vous permettra d'exécuter avec tous les tests d'intégration désactivés par défaut. Pour les exécuter, vous utilisez cette commande:

mvn install -DskipTests=false

Vous devez utiliser Maven Surefire plug - in pour exécuter des tests unitaires et Maven plug - in failsafe pour exécuter des tests d'intégration.

Veuillez suivre ci-dessous si vous souhaitez basculer l'exécution de ces tests à l'aide d'indicateurs.

Configuration Maven

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <configuration>
                <skipTests>${skipUnitTests}</skipTests>
            </configuration>
        </plugin>

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-failsafe-plugin</artifactId>
            <configuration>
                <includes>
                    <include>**/*IT.java</include>
                </includes>
                <skipTests>${skipIntegrationTests}</skipTests>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>integration-test</goal>
                        <goal>verify</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>

        <properties>
            <skipTests>false</skipTests>
            <skipUnitTests>${skipTests}</skipUnitTests>
            <skipIntegrationTests>${skipTests}</skipIntegrationTests>
        </properties>

Ainsi, les tests seront ignorés ou commutés selon les règles de drapeau ci-dessous:

Les tests peuvent être ignorés par les indicateurs ci-dessous:

• -DskipTests ignore les tests unitaires et d'intégration
• -DskipUnitTests ignore les tests unitaires mais exécute les tests d'intégration
• -DskipIntegrationTests ignore les tests d'intégration mais exécute les tests unitaires

Exécution de tests

Exécutez ci-dessous pour exécuter uniquement des tests unitaires

mvn clean test

Vous pouvez exécuter la commande ci-dessous pour exécuter les tests (à la fois unité et intégration)

mvn clean verify

Afin d'exécuter uniquement les tests d'intégration, suivez

mvn failsafe:integration-test

Ou sauter les tests unitaires

mvn clean install -DskipUnitTests

Aussi, pour sauter les tests d'intégration pendant mvn install, suivez

mvn clean install -DskipIntegrationTests

Vous pouvez ignorer tous les tests en utilisant

mvn clean install -DskipTests