¿Cómo hago para que se ejecuten mis pruebas de integración de Maven?

Tengo un proyecto de módulo múltiple maven2 y en cada uno de mis módulos secundarios tengo pruebas JUnit que se nombran Test.javay Integration.javapara pruebas unitarias y pruebas de integración respectivamente. Cuando ejecuto:

mvn test

*Test.javaSe ejecutan todas las pruebas JUnit dentro de los módulos secundarios. Cuando ejecuto

mvn test -Dtest=**/*Integration

ninguna de las Integration.javapruebas se ejecuta dentro de los módulos secundarios.

Estos parecen ser exactamente el mismo comando para mí, pero el que tiene -Dtest = / * Integration ** no funciona, muestra 0 pruebas que se ejecutan en el nivel principal, que no hay ninguna prueba

Puede configurar Surefire de Maven para ejecutar pruebas unitarias y pruebas de integración por separado. En la fase de prueba unitaria estándar, ejecuta todo lo que no coincide con el patrón de una prueba de integración. Luego crea una segunda fase de prueba que ejecuta solo las pruebas de integración.

Aquí hay un ejemplo:

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

El ciclo de vida de construcción de Maven ahora incluye la fase de "prueba de integración" para ejecutar pruebas de integración, que se ejecutan por separado de las pruebas unitarias ejecutadas durante la fase de "prueba". Se ejecuta después de "paquete", por lo que si ejecuta "mvn verificar", "mvn install" o "mvn deploy", las pruebas de integración se ejecutarán en el camino.

Por defecto, la integración de la prueba se ejecuta clases de prueba mencionados **/IT*.java, **/*IT.javay **/*ITCase.java, pero esto se puede configurar.

Para obtener detalles sobre cómo conectar todo esto, consulte el complemento Failsafe , la página de uso de Failsafe (no está correctamente vinculada desde la página anterior mientras escribo esto), y también consulte esta publicación del blog de Sonatype .

He hecho EXACTAMENTE lo que quieres hacer y funciona muy bien. Las pruebas unitarias "* Pruebas" siempre se ejecutan, y "* IntegrationTests" solo se ejecutan cuando se realiza una verificación o instalación de mvn. Aquí está el fragmento de mi POM. serg10 casi lo hizo bien ... pero no del todo.

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

¡Buena suerte!

Puede dividirlos muy fácilmente usando las categorías JUnit y Maven.
Esto se muestra muy, muy brevemente a continuación dividiendo la unidad y las pruebas de integración.

Definir una interfaz de marcador

El primer paso para agrupar una prueba usando categorías es crear una interfaz de marcador.
Esta interfaz se utilizará para marcar todas las pruebas que desea ejecutar como pruebas de integración.

public interface IntegrationTest {}

Marque sus clases de prueba

Agregue la anotación de categoría a la parte superior de su clase de prueba. Toma el nombre de su nueva interfaz.

import org.junit.experimental.categories.Category;

@Category(IntegrationTest.class)
public class ExampleIntegrationTest{

    @Test
    public void longRunningServiceTest() throws Exception {
    }

}

Configurar las pruebas de la unidad Maven

La belleza de esta solución es que nada cambia realmente para el lado de las pruebas unitarias.
Simplemente agregamos un poco de configuración al plugin maven surefire para que ignore cualquier prueba de integración.

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

Cuando haces un mvn clean test, solo se ejecutarán las pruebas unitarias sin marcar.

Configurar las pruebas de integración de Maven

Nuevamente, la configuración para esto es muy simple.
Utilizamos el complemento a prueba de fallos estándar y lo configuramos para ejecutar solo las pruebas de integración.

<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 configuración utiliza un objetivo de ejecución estándar para ejecutar el complemento a prueba de fallos durante la fase de prueba de integración de la compilación.

Ahora puedes hacer un mvn clean install.
Esta vez, además de las pruebas unitarias en ejecución, las pruebas de integración se ejecutan durante la fase de prueba de integración.

Deberías intentar usar el complemento maven failsafe . Puede decirle que incluya un cierto conjunto de pruebas.

Por defecto, Maven solo ejecuta pruebas que tienen Test en algún lugar del nombre de la clase.

Cambie el nombre a IntegrationTest y probablemente funcionará.

Alternativamente, puede cambiar la configuración de Maven para incluir ese archivo, pero probablemente sea más fácil y mejor solo nombrar sus pruebas SomethingTest.

De inclusiones y exclusiones de pruebas :

Por defecto, el complemento Surefire incluirá automáticamente todas las clases de prueba con los siguientes patrones comodín:

• \*\*/Test\*.java - incluye todo su subdirectorio y todos los nombres de archivo java que comienzan con "Prueba".
• \*\*/\*Test.java - incluye todo su subdirectorio y todos los nombres de archivo java que terminan con "Prueba".
• \*\*/\*TestCase.java - incluye todo su subdirectorio y todos los nombres de archivo java que terminan con "TestCase".

Si las clases de prueba no van con la convención de nomenclatura, configure Surefire Plugin y especifique las pruebas que desea incluir.

Otra forma de ejecutar pruebas de integración con Maven es hacer uso de la función de perfil:

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

Al ejecutar 'mvn clean install' se ejecutará la compilación predeterminada. Como se especificó anteriormente, las pruebas de integración serán ignoradas. La ejecución de 'mvn clean install -P Integration-tests' incluirá las pruebas de integración (también ignoro mis pruebas de integración por etapas). Además, tengo un servidor CI que ejecuta mis pruebas de integración todas las noches y para eso emito el comando 'mvn test -P Integration-tests' .

Puede seguir la documentación de Maven para ejecutar las pruebas unitarias con la compilación y ejecutar las pruebas de integración por separado.

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

Esto le permitirá ejecutar con todas las pruebas de integración deshabilitadas de forma predeterminada. Para ejecutarlos, usa este comando:

mvn install -DskipTests=false

Debe usar el complemento maven surefire para ejecutar pruebas unitarias y el complemento maven failsafe para ejecutar pruebas de integración.

Siga a continuación si desea alternar la ejecución de estas pruebas con banderas.

Configuración 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>

Por lo tanto, las pruebas se omitirán o cambiarán de acuerdo con las siguientes reglas de bandera:

Las pruebas se pueden omitir con los siguientes indicadores:

• -DskipTests omite las pruebas unitarias y de integración
• -DskipUnitTests omite pruebas unitarias pero ejecuta pruebas de integración
• -DskipIntegrationTests se saltea las pruebas de integración pero ejecuta pruebas unitarias

Ejecutando pruebas

Ejecute a continuación para ejecutar solo pruebas unitarias

mvn clean test

Puede ejecutar el siguiente comando para ejecutar las pruebas (tanto la unidad como la integración)

mvn clean verify

Para ejecutar solo pruebas de integración, siga

mvn failsafe:integration-test

O saltear pruebas unitarias

mvn clean install -DskipUnitTests

Además, para omitir las pruebas de integración durante mvn install, siga

mvn clean install -DskipIntegrationTests

Puedes saltarte todas las pruebas usando

mvn clean install -DskipTests