Como faço para executar meus testes de integração com o Maven

Eu tenho um projeto multi-módulo do maven2 e em cada um dos meus módulos filhos tenho testes JUnit nomeados Test.javae Integration.javapara testes de unidade e testes de integração, respectivamente. Quando executo:

mvn test

todos os testes JUnit *Test.javanos módulos filhos são executados. Quando executo

mvn test -Dtest=**/*Integration

nenhum dos Integration.javatestes é executado nos módulos filhos.

Estes parecem ser exatamente o mesmo comando para mim, mas aquele com o -Dtest = / * Integration ** não funciona, exibe 0 testes sendo executados no nível pai, que não existem testes

Você pode configurar o Maven's Surefire para executar testes de unidade e testes de integração separadamente. Na fase de teste de unidade padrão, você executa tudo o que não corresponde a um teste de integração. Em seguida, você cria uma segunda fase de teste que executa apenas os testes de integração.

Aqui está um exemplo:

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

O ciclo de vida de construção do Maven agora inclui a fase "teste de integração" para executar testes de integração, que são executados separadamente dos testes de unidade executados durante a fase "teste". Ele é executado após o "pacote", portanto, se você executar "mvn Verifique", "mvn install" ou "mvn deploy", os testes de integração serão executados ao longo do caminho.

Por padrão, a integração-teste é executado classes de teste nomeados **/IT*.java, **/*IT.javae **/*ITCase.java, mas isso pode ser configurado.

Para obter detalhes sobre como conectar tudo isso, consulte o plug-in Failsafe , a página de uso do Failsafe (não está corretamente vinculada à página anterior enquanto escrevo isso) e também confira esta postagem no blog Sonatype .

Fiz exatamente o que você quer fazer e funciona muito bem. Testes de unidade "* Tests" sempre são executados e "* IntegrationTests" são executados apenas quando você faz uma verificação mvn ou instala mvn. Aqui está o trecho do meu POM. serg10 quase acertou .... mas não exatamente.

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

Boa sorte!

Você pode dividi-los facilmente usando as categorias JUnit e Maven.
Isso é mostrado muito, muito brevemente abaixo, dividindo os testes de unidade e integração.

Definir uma interface de marcador

A primeira etapa no agrupamento de um teste usando categorias é criar uma interface de marcador.
Essa interface será usada para marcar todos os testes que você deseja executar como testes de integração.

public interface IntegrationTest {}

Marque suas aulas de teste

Adicione a anotação da categoria ao topo da sua classe de teste. Leva o nome da sua nova interface.

import org.junit.experimental.categories.Category;

@Category(IntegrationTest.class)
public class ExampleIntegrationTest{

    @Test
    public void longRunningServiceTest() throws Exception {
    }

}

Configurar testes de unidade Maven

A beleza desta solução é que nada realmente muda para o lado do teste de unidade.
Simplesmente adicionamos algumas configurações ao plug-in maven surefire para ignorar qualquer teste de integração.

<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 você faz um mvn clean test, apenas seus testes de unidade não marcados serão executados.

Configurar testes de integração do Maven

Novamente, a configuração para isso é muito simples.
Usamos o plug-in padrão à prova de falhas e o configuramos para executar apenas os testes de integração.

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

A configuração usa uma meta de execução padrão para executar o plug-in à prova de falhas durante a fase de teste de integração da compilação.

Agora você pode fazer um mvn clean install.
Desta vez, assim como os testes de unidade em execução, os testes de integração são executados durante a fase de teste de integração.

Você deve tentar usar o plug-in à prova de falhas maven . Você pode dizer para incluir um determinado conjunto de testes.

Por padrão, o Maven executa apenas testes que possuem Test em algum lugar no nome da classe.

Renomeie para IntegrationTest e provavelmente funcionará.

Como alternativa, você pode alterar a configuração do Maven para incluir esse arquivo, mas provavelmente é mais fácil e melhor nomear seus testes como SomethingTest.

Das inclusões e exclusões de testes :

Por padrão, o Surefire Plugin incluirá automaticamente todas as classes de teste com os seguintes padrões curinga:

• \*\*/Test\*.java - inclui todos os seus subdiretórios e todos os nomes de arquivos java que começam com "Teste".
• \*\*/\*Test.java - inclui todos os seus subdiretórios e todos os nomes de arquivos java que terminam com "Teste".
• \*\*/\*TestCase.java - inclui todos os seus subdiretórios e todos os nomes de arquivos java que terminam com "TestCase".

Se as classes de teste não atenderem à convenção de nomenclatura, configure o Surefire Plugin e especifique os testes que você deseja incluir.

Outra maneira de executar testes de integração com o Maven é usar o recurso 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>
...

Executando 'mvn clean install' executará a compilação padrão. Conforme especificado acima, os testes de integração serão ignorados. A execução do 'mvn clean install -P integration-tests' incluirá os testes de integração (eu também ignoro meus testes de integração de preparação). Além disso, tenho um servidor de IC que executa meus testes de integração todas as noites e, para isso, emito o comando 'mvn test -P integration-tests' .

Você pode seguir a documentação do maven para executar os testes de unidade com a construção e executar os testes de integração separadamente.

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

Isso permitirá que você execute com todos os testes de integração desativados por padrão. Para executá-los, use este comando:

mvn install -DskipTests=false

Você deve usar o plug - in maven surefire para executar testes de unidade e o plugin maven fail-safe para executar testes de integração.

Siga abaixo se você deseja alternar a execução desses testes usando sinalizadores.

Configuração do 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>

Portanto, os testes serão ignorados ou alternados de acordo com as regras de sinalização abaixo:

Os testes podem ser ignorados pelas bandeiras abaixo:

• -DskipTests pula os testes de unidade e de integração
• -DskipUnitTests pula testes de unidade, mas executa testes de integração
• -DskipIntegrationTests pula testes de integração, mas executa testes de unidade

Executando testes

Execute abaixo para executar apenas testes de unidade

mvn clean test

Você pode executar o comando abaixo para executar os testes (unidade e integração)

mvn clean verify

Para executar apenas testes de integração, siga

mvn failsafe:integration-test

Ou pule os testes de unidade

mvn clean install -DskipUnitTests

Além disso, para ignorar os testes de integração durante mvn install, siga

mvn clean install -DskipIntegrationTests

Você pode pular todos os testes usando

mvn clean install -DskipTests