Como posso executar todos os testes de unidade JUnit, exceto aqueles que termina em “IntegrationTest” no meu projeto IDEA IntelliJ usando o corredor de teste integrado?

Question

Basicamente, eu quero correr todo unidade testes no meu projeto IDEA IntelliJ (excluindo testes de integração JUnit), usando o conjunto estático (método) de JUnit JUnit. Por que usar a suíte método estático ()? Porque eu posso então usar corredor de teste JUnit do IntelliJ IDEA para executar todos os testes de unidade no meu aplicativo (e facilmente excluir todos os testes de integração, convenção de nomenclatura). O código até agora se parece com isso:

package com.acme;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class AllUnitTests extends TestCase {

    public static Test suite() {
        List classes = getUnitTestClasses();
        return createTestSuite(classes);
    }

    private static List getUnitTestClasses() {
        List classes = new ArrayList();
        classes.add(CalculatorTest.class);
        return classes;
    }

    private static TestSuite createTestSuite(List allClasses) {
        TestSuite suite = new TestSuite("All Unit Tests");
        for (Iterator i = allClasses.iterator(); i.hasNext();) {
            suite.addTestSuite((Class<? extends TestCase>) i.next());
        }
        return suite;
    }

}

Os getUnitTestClasses () método deve ser reescrito para adicionar todas as classes do projeto se estende TestCase, exceto se as extremidades nome da classe no "IntegrationTest".

Eu sei que posso fazer isso facilmente em Maven por exemplo, mas eu preciso fazê-lo em IntelliJ IDEA para que eu possa usar o corredor de teste integrado - I como a barra verde:)

Answer 1

Eu escrevi algum código para fazer a maioria do trabalho. Ele funciona somente se seus arquivos estão no disco local, em vez de em um frasco. Tudo que você precisa é de uma classe no pacote. Você poderia, por isso, criar uma classe Locator.java, apenas para ser capaz de encontrar o pacote.

public class ClassEnumerator {
    public static void main(String[] args) throws ClassNotFoundException {
        List<Class<?>> list = listClassesInSamePackage(Locator.class, true);

        System.out.println(list);
    }

    private static List<Class<?>> listClassesInSamePackage(Class<?> locator, boolean includeLocator) 
                                                                      throws ClassNotFoundException {

        File packageFile = getPackageFile(locator);

        String ignore = includeLocator ? null : locator.getSimpleName() + ".class";

        return toClassList(locator.getPackage().getName(), listClassNames(packageFile, ignore));
    }

    private static File getPackageFile(Class<?> locator) {
        URL url = locator.getClassLoader().getResource(locator.getName().replace(".", "/") + ".class");
        if (url == null) {
            throw new RuntimeException("Cannot locate " + Locator.class.getName());
        }

        try {
        return new File(url.toURI()).getParentFile();
        }
        catch (URISyntaxException e) {
            throw new RuntimeException(e);
        }
    }

    private static String[] listClassNames(File packageFile, final String ignore) {
        return packageFile.list(new FilenameFilter(){
            @Override
            public boolean accept(File dir, String name) {
                if (name.equals(ignore)) {
                    return false;
                }
                return name.endsWith(".class");
            }
        });
    }

    private static List<Class<?>> toClassList(String packageName, String[] classNames)
                                                             throws ClassNotFoundException {

        List<Class<?>> result = new ArrayList<Class<?>>(classNames.length);
        for (String className : classNames) {
            // Strip the .class
            String simpleName = className.substring(0, className.length() - 6);

            result.add(Class.forName(packageName + "." + simpleName));
        }
        return result;
    }
}

Answer 2

Que tal colocar cada grande grupo de testes JUnit em seu próprio pacote de raiz. Eu uso essa estrutura do pacote no meu projeto:

test.
  quick.
    com.acme
  slow.
    com.acme

Sem qualquer codificação, você pode configurar IntelliJ para executar todos os testes, apenas as rápidas ou apenas aquelas lentas.

Answer 3

Que tal usar JUnit4 ea Suite-Runner?

Exemplo:

@RunWith(Suite.class)
@Suite.SuiteClasses({
UserUnitTest.class,
AnotherUnitTest.class
})
public class UnitTestSuite {}

Eu fiz uma pequena Shell-Script para encontrar todos Unit-testes e outra para encontrar meus integração em testes. Dê uma olhada no meu blog: http://blog.timomeinen.de/ 2010/02 / find-all-junit-testes-in-a-projeto /

Se você usar o Spring TestContext você pode usar o @IfProfile anotações para declarar testes diferentes.

Atenciosamente, Timo Meinen

Answer 4

Spring implementou uma excelente função de pesquisa classpath no PathMatchingResourcePatternResolver. Se você usar o classpath *: prefixo, você pode encontrar todos os recursos, incluindo aulas em uma determinada hierarquia, e mesmo filtrá-los se quiser. Então você pode usar os filhos de AbstractTypeHierarchyTraversingFilter, AnnotationTypeFilter e AssignableTypeFilter para filtrar esses recursos quer por anotações nível de classe ou em interfaces que implementam.

http : //static.springsource.org/spring/docs/2.0.x/api/org/springframework/core/io/support/PathMatchingResourcePatternResolver.html

http : //static.springsource.org/spring/docs/2.5.x/api/org/springframework/core/type/filter/AbstractTypeHierarchyTraversingFilter.html

Answer 5

Solução: https://github.com/MichaelTamm/junit-toolbox
Usar as seguintes funções

@RunWith(WildcardPatternSuite.class)
@SuiteClasses({"**/*.class", "!**/*IntegrationTest.class"})
public class AllTestsExceptionIntegrationSuit {
}

supondo que você seguindo um padrão de nomenclatura onde testes de integração terminar em ... IntegrationTest e você colocar o arquivo no pacote mais alto (por isso o ** / *. Pesquisa classe terá a oportunidade de pegar todos os seus testes )