Executar testes JUnit em paralelo em uma compilação de Maven?

Question

Eu estou usando JUnit 4.4 e Maven e eu tenho um grande número de longo execução de testes de integração.

Quando se trata de conjuntos de testes paralelização existem algumas soluções que permitam-me para executar cada método de teste em um único teste de classe em paralelo. Mas tudo isso exige que eu mudar os testes de uma forma ou de outra.

Eu realmente acho que seria uma solução mais limpa tanto para executar X diferentes classes de teste em tópicos X em paralelo. Tenho centenas de testes, então eu realmente não me importo sobre enfiando-teste aulas individuais.

Existe alguma maneira de fazer isso?

Answer 1

De JUnit 4.7 agora é possível executar testes em paralelo sem usar TestNG. Na verdade, tem sido possível desde 4.6, mas há uma série de correções que estão sendo feitas em 4.7 que irá torná-lo uma opção viável. Você também pode executar testes paralelos com mola, que você pode ler sobre aqui

Answer 2

Use maven plugin:

<build>
    <plugins>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.7.1</version>
        <configuration>
            <parallel>classes</parallel>
            <threadCount>5</threadCount>
        </configuration>
    </plugin>
    </plugins>
</build>

Answer 3

Inspirado pela experimental do JUnit ParallelComputer corredor Eu construí minha própria ParallelSuite e < sTRONG> ParallelParameterized corredores. Usando esses corredores pode-se conjuntos de testes facilmente paralelizar e testes parametrizadas.

ParallelSuite.java

public class ParallelSuite extends Suite {

    public ParallelSuite(Class<?> klass, RunnerBuilder builder) throws InitializationError {

        super(klass, builder);

        setScheduler(new RunnerScheduler() {

            private final ExecutorService service = Executors.newFixedThreadPool(4);

            public void schedule(Runnable childStatement) {
                service.submit(childStatement);
            }

            public void finished() {
                try {
                    service.shutdown();
                    service.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
                } catch (InterruptedException e) {
                    e.printStackTrace(System.err);
                }
            }
        });
    }
}

ParallelParameterized.java

public class ParallelParameterized extends Parameterized {

    public ParallelParameterized(Class<?> arg0) throws Throwable {

        super(arg0);

        setScheduler(new RunnerScheduler() {

            private final ExecutorService service = Executors.newFixedThreadPool(8);

            public void schedule(Runnable childStatement) {
                service.submit(childStatement);
            }

            public void finished() {
                try {
                    service.shutdown();
                    service.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
                } catch (InterruptedException e) {
                    e.printStackTrace(System.err);
                }
            }
        });
    }
}

O uso é simples. mudança apenas @RunWith anotações valor a um destes * Paralelo classes.

@RunWith(ParallelSuite.class)
@SuiteClasses({ATest.class, BTest.class, CTest.class})
public class ABCSuite {}

Answer 4

tempus fugit- oferece algo semelhante, verifique a documentação para mais detalhes. Ele se baseia em JUnit 4.7 e você só marcar o seu teste para @RunWith(ConcurrentTestRunner).

Felicidades

Answer 5

TestNG pode fazer isso (este foi o meu primeiro reflexo - então eu vi que você já está tendo um monte de casos de teste).

Para JUnit, olhada paralelo junit .

Answer 6

Você pode conferir a biblioteca de código aberto - Teste Load Balancer . Ele faz exatamente o que você pedir - executar classes de teste diferentes em paralelo. Este integra a nível ant-junit para que você não tem que mudar seus testes de qualquer maneira. Eu sou um dos autores da biblioteca.

Além disso, pensar em não executá-los em tópicos como você pode precisar de um sandbox nível do processo. Por exemplo, se você está batendo um DB em seus testes de integração, você não quer um teste falhar porque outro teste acrescentou alguns dados em um segmento diferente. Na maioria das vezes, os testes não são escritas com isso em mente.

Finalmente, como ter resolvido este problema até agora?

Answer 7

Você pode executar os testes em paralelo usando ParallelComputer fornecido pelo próprio JUnit. Aqui está um pequeno trecho para você começar.

Class[] cls = { TestCase1.class, TestCase2.class };
Result result = JUnitCore.runClasses(ParallelComputer.classes(), cls);
List<Failure> failures = result.getFailures();

Isso vai ajudar quando você precisa executar testes a partir do código, uma vez que não tem dependências em Maven ou quaisquer outras ferramentas de gerenciamento de configuração.

Por favor note que, este irá executar todos os casos de teste em paralelo, se você tiver quaisquer dependências entre diferentes casos de teste que poderia resultar em falsos positivos. Você não deve ter testes interdependentes de qualquer maneira.

Answer 8

Você pode mudar o seu teste para ser teste testng em um minuto (você só precisa importações de mudança), TestNG é o melhor em teste paralelo.

Answer 9

Você poderia tentar Gridgain que permite executar distribuir seus testes através de uma grade de computação.