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

170

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

Peter Delaney
fonte
4
A resposta de Kief deve ser a aceita, pois é o padrão atual para definir testes de integração no Maven.
precisa saber é o seguinte

Respostas:

110

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>
serg10
fonte
1
Eu configurei isso como você disse e apenas os arquivos * Test e não * Integration.java serão executados ao executar: mvn install Eu preciso executar meu * Test.java como padrão, mas para minha compilação noturna, preciso executar os dois * Test .java e * Integration.java. Eu tenho que executar mvn instalar depois mude para cada diretório sub-criança e executar mvn -Dtest = ** / * Teste de Integração
Peter Delaney
66
Você deve usar o plug-in Fail-safe para teste de integração, não o plug-in infalível. Ele não deixará a construção até após a fase de pós-integração é completa; permitindo que você desmonte os recursos de teste (um servidor da web, por exemplo) antes que a compilação falhe. Portanto, à prova de falhas.
John Gordon
para mim, como parte da fase de pré-integração, o servidor jetty é iniciado. A última linha do log é: [INFO] Iniciou o Jetty Server. Depois disso, nada acontece. Fica preso. O plugin maven surefire failafe não executa testes nem o servidor jetty para. Alguma idéia do que está errado? Estou usando a mesma configuração especificada por você.
Tarun Kumar
6
Esta resposta está muito desatualizada e deve ser atualizada ou removida.
Zac Thompson
Alguma ajuda com este? stackoverflow.com/questions/48639730/…
Rohit Barnwal
250

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 .

Kief
fonte
1
@WillV Correct. Cemitério do Codehaus. E o maven-failafe-plugin está no Apache agora. Desculpe. :)
Jin Kwon
38
Por padrão, mvn integration-testtambém executa testes de unidade (usando via surefire), mas mvn failsafe:integration-testexecuta apenas os testes de integração à prova de falhas.
Shadow Man
22
Incrivelmente, a documentação do plugin Failsafe, a página de uso e as perguntas frequentes não mencionam que ele executa classes de teste denominadas * / IT .java, ** / * IT.java e ** / * ITCase.java ...
Henno Vermeulen
1
Se for executado após a packagefase, isso significa que devo colocar todo o meu código-fonte Java IT em src/main/javavez de estar src/test/javacerto?
Bruce Sun
5
@HennoVermeulen Eu estava confuso sobre o que nomear testes também. Está descrito em Inclusões e exclusões de testes . É bom que os padrões possam ser substituídos, mas seria bom se eles mencionassem os padrões mais cedo.
Joshua Taylor
63

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!

HDave
fonte
Exatamente o que tentei fazer, mas meus testes de integração continuaram em execução durante a fase de teste do mvn, pois NÃO PULSO O PADRÃO. Eu pensei que configurar a execução do teste iria substituí-lo. Como você explicou, apenas adiciona uma nova execução (portanto, tudo seria executado duas vezes). Então, para mim, a peça estava faltando. +1 Como essa configuração responde 100% à pergunta
Nils Schmidt
2
Em seguida, sinta-se à vontade para marcar a caixa para que esta resposta seja a resposta!
usar o seguinte código
para mim, como parte da fase de pré-integração, o servidor jetty é iniciado. A última linha do log é: [INFO] Iniciou o Jetty Server. Depois disso, nada acontece. Fica preso. O plugin maven surefire failafe não executa testes nem o servidor jetty para. Alguma idéia do que está errado? Estou usando a mesma configuração especificada por você.
Tarun Kumar
@Tarun - faça uma nova pergunta com relação a seu problema
HDave
2
Essa deve ser a resposta aceita. O objetivo associado do maven é: clean compile integration-test -Dmaven.test.failure.ignore=false
Neill Lima
31

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.

John Dobie
fonte
Eu pensei que JUnit não tem mais segredos para mim. Bom local!
gertas
4
Isso só funciona se a interface do marcador já existir em algum lugar disponível para o Maven. Não funciona se a sua interface de marcador existir em outro módulo da mesma compilação de vários módulos.
EngineerBetter_DJ
@EngineerBetter_DJ, o que você quer dizer com isso? Você não pode fazer isso se tiver uma configuração maven baseada em vários projetos?
matthieusb
16

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

James Kingsbery
fonte
1
+1 É isso que eu uso. Funciona bem e permite que você faça a configuração pré / pós, como iniciar e desligar um contêiner de servlet local.
Mdma
maven-failsafe-pluginfoi para Plugin Graveyard
Jin Kwon
9
A página do cemitério apenas diz que o failsafeplugin foi movido para maven-failsafe-plugin. Parece que maven-failsafe-pluginainda está ativo (os documentos foram enviados pela última vez em março de 2014).
James Kingsbery
13

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.

cleto
fonte
Oi e obrigado. Eu tenho dois tipos de testes normais do POJO Junit, chamados SomethingTest.java, que são demitidos. Também tenho testes de integração chamados SomethingIntegration.java, que não são acionados. O SomethingTest.java é acionado via mvn test ou mvn install. Os segundos testes não são disparados. teste mvn -Dtest = ** / * Integração
Peter Delaney
.. e por "Maven executa apenas testes que possuem Teste em algum lugar no nome da classe", você quer dizer "o plug-in Maven surefire executa apenas testes que possuem Teste em algum lugar no nome da classe".
Joshua Davis
1
Não é "em algum lugar do nome da classe" é "o nome da classe termina com Teste", por exemplo, o MyTest funciona, mas o MyTests não funciona
Julian
10

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

Jorge
fonte
1
Por que você não usaria a fase de teste de integração? Os perfis podem ser usados ​​para testes de integração em vários servidores de aplicativos, etc., como o Arquillian faz. Não sou especialista em Maven, mas acho que os especialistas podem dizer que isso não é muito 'Maven-y'.
Joshua Davis
1
@ Josué Eu acho que faço dessa maneira porque meus testes de integração levam pelo menos 5 minutos para serem executados e emito 'mvn clean install' muitas vezes por dia porque preciso atualizar meus artefatos no meu repo maven local. De acordo com o que as pessoas estão dizendo acima, executar 'install' fará com que a fase de teste de integração seja executada, fazendo com que eu perca um tempo precioso do desenvolvedor.
Jorge
Hmm ... não tenho certeza sobre 'instalar' executando o teste de integração. De qualquer forma, eu ainda usaria a fase em vez de um perfil. Os perfis são melhor usado para coisas como o apoio diferentes servidores de aplicação, etc.
Joshua Davis
1
Vou seguir em frente e brincar com isso então. Obrigado pelo conselho!
Jorge
@jorge Acho que o objetivo correto a ser usado aqui seria verificar, certo?
Kilokahn
1

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
Dherik
fonte
0

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