java - run - ¿Cómo puedo ejecutar todas las pruebas de la unidad JUnit excepto las que terminan en "IntegrationTest" en mi proyecto IntelliJ IDEA utilizando el corredor de prueba integrado?
run junit test intellij (5)
Básicamente quiero ejecutar todas las pruebas de unidad JUnit en mi proyecto IntelliJ IDEA (excluyendo las pruebas de integración JUnit), usando el método estático suite () de JUnit. ¿Por qué usar el método static suite ()? Porque puedo usar el corrector de prueba JUnit de IntelliJ IDEA para ejecutar todas las pruebas unitarias en mi aplicación (y excluir fácilmente todas las pruebas de integración nombrando la convención). El código hasta ahora se ve así:
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;
}
}
El método getUnitTestClasses () se debe volver a escribir para agregar todas las clases de proyectos que se extiendan a TestCase, excepto si el nombre de la clase termina en "IntegrationTest".
Sé que puedo hacerlo fácilmente en Maven, por ejemplo, pero tengo que hacerlo en IntelliJ IDEA para poder usar el corrector de prueba integrado. Me gusta la barra verde :)
¿Qué hay de poner cada grupo principal de pruebas junit en su propio paquete raíz? Uso esta estructura de paquete en mi proyecto:
test.
quick.
com.acme
slow.
com.acme
Sin ninguna codificación, puede configurar IntelliJ para ejecutar todas las pruebas, solo las rápidas o solo las lentas.
He escrito un código para hacer la mayor parte del trabajo. Funciona solo si sus archivos están en el disco local en lugar de en un JAR. Todo lo que necesitas es una clase en el paquete. Para este propósito, podría crear una clase Locator.java, solo para poder encontrar el paquete.
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;
}
}
¿Qué hay de usar JUnit4 y Suite-Runner?
Ejemplo:
@RunWith(Suite.class)
@Suite.SuiteClasses({
UserUnitTest.class,
AnotherUnitTest.class
})
public class UnitTestSuite {}
Hice un pequeño script de shell para encontrar todas las pruebas unitarias y otra para encontrar mis pruebas de integración. Echa un vistazo a la entrada de mi blog: http://blog.timomeinen.de/2010/02/find-all-junit-tests-in-a-project/
Si usa Spring TestContext, puede usar la Anotación @IfProfile para declarar diferentes pruebas.
Un cordial saludo, Timo Meinen
Spring ha implementado una excelente función de búsqueda de classpath en PathMatchingResourcePatternResolver. Si usa classpath *: prefix, puede encontrar todos los recursos, incluidas las clases en una jerarquía determinada, e incluso filtrarlos si lo desea. Luego puede usar los elementos secundarios de AbstractTypeHierarchyTraversingFilter, AnnotationTypeFilter y AssignableTypeFilter para filtrar esos recursos en anotaciones a nivel de clase o en las interfaces que implementan.
Solución: https://github.com/MichaelTamm/junit-toolbox
Use las siguientes características
@RunWith(WildcardPatternSuite.class)
@SuiteClasses({"**/*.class", "!**/*IntegrationTest.class"})
public class AllTestsExceptionIntegrationSuit {
}
asumiendo que sigue un patrón de nombres donde las pruebas de integración terminan en ... IntegrationTest y coloca el archivo en el paquete más alto (para que la búsqueda de la clase ** / *. tenga la oportunidad de recoger todas sus pruebas)