proyecto - Saltarse pruebas en algunos módulos en Maven

maven tutorial pdf

Question

Me gustaría que mis compilaciones Maven ejecuten la mayoría de las pruebas unitarias. Pero hay pruebas unitarias en un proyecto que son más lentas y me gustaría generalmente excluirlas; y ocasionalmente encenderlos.

Pregunta : ¿Cómo hago esto?

Sé acerca de -Dmaven.test.skip=true , pero eso desactiva todas las pruebas unitarias.

También sé sobre omitir las pruebas de integración, que se describen here . Pero no tengo pruebas de integración, solo pruebas unitarias, y no tengo llamadas explícitas al plugin maven-surefire. (Estoy usando Maven 2 con el plugin Eclipse-Maven).

Answer 1

¿Qué hay sobre saltarse pruebas solo en este módulo?

En el pom.xml de este módulo:

<project>
  [...]
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.4.2</version>
        <configuration>
          <skipTests>true</skipTests>
        </configuration>
      </plugin>
    </plugins>
  </build>
  [...]
</project>

Eventualmente, puede crear un perfil que deshabilitará las pruebas (sigue siendo el pom.xml del módulo):

<project>
  [...]
  <profiles>
    <profile>
      <id>noTest</id>
      <activation>
        <property>
          <name>noTest</name>
          <value>true</value>
        </property>
      </activation>
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.4.2</version>
            <configuration>
              <skipTests>true</skipTests>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>
  [...]
</project>

Con la última solución, si ejecuta mvn clean package , ejecutará todas las pruebas. Si ejecuta mvn clean package -DnoTest=true , no ejecutará las pruebas para este módulo.

Answer 2

Al utilizar Surefire Plugin 2.19, simplemente puede excluir las pruebas que no desea con expresiones regulares:

mvn ''-Dtest=!%regex[.*excludedString.*]'' test

El comando anterior excluirá todas las pruebas que contienen excludedString .

NB1 Si se utiliza comillas dobles (") en lugar de apóstrofo (''), el comando no se interpretará correctamente y producirá resultados inesperados. (Probado con bash 3.2.57)

NB2 Se debe prestar especial atención a los proyectos en los que se utiliza una versión múltiple del plugin surefire. Las versiones de surefire anteriores a 2.19 no ejecutarán ninguna prueba porque no admiten expresiones regulares.

Gestión de versiones (podría ser una buena idea agregar esto en el archivo pom padre):

<build>
  <pluginManagement>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.19.1</version>
      </plugin>
    </plugins>
  </pluginManagement>
</build>

Ejemplos de comandos de compilación que omiten pruebas: https://artbcode.wordpress.com/2016/11/28/how-to-skip-a-subset-of-the-unit-tests/

Answer 3

Creo que esto es más fácil, y también tiene el beneficio de trabajar para pruebas no seguras (en mi caso, FlexUnitTest)

<profile>
   <id>noTest</id>
    <properties>
       <maven.test.skip>true</maven.test.skip>
    </properties>
 </profile>

Answer 4

Si tiene un gran proyecto de varios módulos y le gustaría omitir las pruebas solo en ciertos módulos sin la necesidad de cambiar cada uno de los archivos pom.xml del módulo con configuración personalizada y creación de perfiles, puede agregar lo siguiente al padre pom.xml archivo:

<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>build-helper-maven-plugin</artifactId>
            <version>1.12</version>
            <executions>
                <execution>
                    <id>regex-property</id>
                    <goals>
                        <goal>regex-property</goal>
                    </goals>
                    <configuration>
                        <name>maven.test.skip</name>
                        <value>${project.artifactId}</value>
                        <regex>(module1)|(module3)</regex>
                        <replacement>true</replacement>
                        <failIfNoMatch>false</failIfNoMatch>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>
<modules>
    <module>module1</module>
    <module>module2</module>
    <module>module3</module>
</modules>

Gracias al build-helper-maven-plugin , en realidad comprobarás dinámicamente si estás en un cierto módulo o no durante la compilación, a través de la propiedad project.artifactId (apuntando a cada módulo artifactId durante la compilación), la regex buscaría entonces la coincidencia para ciertos valores (los nombres de los módulos para los que desea omitir las pruebas) y maven.test.skip propiedad maven.test.skip consecuencia (configurándola en true ).

En este caso, las pruebas serán omitidas para el module1 y el module3 mientras se ejecuta correctamente para el module2 , es decir, según lo expresado por la expresión regular.

La ventaja de este enfoque es tenerlo dinámico y centralizado (en el pom.xml principal), por lo tanto, mejor para el mantenimiento: puede agregar o eliminar módulos en cualquier momento simplemente cambiando la expresión regular simple anterior.

Obviamente, si este no es el comportamiento predeterminado de la compilación (caso recomendado), siempre puede envolver el fragmento anterior en un perfil de experto .

También podría ir más allá y tener un comportamiento dinámico basado en su entrada:

<properties>
    <test.regex>none</test.regex>
</properties>

<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>build-helper-maven-plugin</artifactId>
            <version>1.12</version>
            <executions>
                <execution>
                    <id>regex-property</id>
                    <goals>
                        <goal>regex-property</goal>
                    </goals>
                    <configuration>
                        <name>maven.test.skip</name>
                        <value>${project.artifactId}</value>
                        <regex>${test.regex}</regex>
                        <replacement>true</replacement>
                        <failIfNoMatch>false</failIfNoMatch>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Aquí en realidad estamos reemplazando el valor regex con una propiedad, test.regex , con valor predeterminado en none (o lo que no corresponda con ningún nombre de módulo o, también, los emparejamientos de omisión predeterminados necesarios).

Entonces, desde la línea de comando, podríamos tener

mvn clean test -Dtest.regex="(module1)" > will skip tests only for module1
mvn clean test -Dtest.regex="(module1)|(module2)" > will skip tests on module1 and module2
mvn clean test -Dtest.regex="(module1)|(module2)|(module3)" > will skip the three module tests
mvn clean test -Dtest.regex=".+" > will skip all module tests
mvn clean test > would not skip anything (or fall back on default behavior)

Es decir, luego, en tiempo de ejecución, usted decide, sin necesidad de cambiar el archivo pom.xml o activar ningún perfil.

Answer 5

Tuve una necesidad ligeramente diferente de esta pregunta que puede ser útil. Quería excluir de la línea de comandos algunas pruebas diferentes de diferentes paquetes, por lo que un comodín único no lo haría.

Encontré en las reglas de documentación de Maven Failsafe para exclusiones que puede especificar una lista separada por comas de exclusiones de expresiones regulares o comodines: https://maven.apache.org/surefire/maven-failsafe-plugin/examples/inclusion-exclusion.html

Entonces mi archivo se parecía a esto:

<excludes>
    <exclude>${exclude.slow.tests}</exclude>
</excludes>

y mi línea de comando incluye esto:

mvn install "-Dexclude.slow.tests=**/SlowTest1.java, **/package/ofslowtests/*.java, **/OtherSlowTest.java"

Para mí, el ingrediente clave era obtener un montón de pruebas en una propiedad maven en una única declaración de exclusión.