java.lang.Exception: Pas d'exécutable méthodes exception dans l'exécution de JUnits

Cette solution s'applique à un très faible pourcentage de personnes, généralement les gens à mettre en œuvre leur propre test JUnit coureurs et en utilisant un chargeur de classe.

Cela peut se produire lorsque vous chargez une classe à partir d'un autre chargeur de classe, puis essayez d'exécuter le test à partir d'une instance de JUnitCore chargé de la système chargeur de classe. Exemple:

//Load class
URLClassLoader cl = new URLClassLoader(myTestUrls, null);
Class<?>[] testCls = cl.loadClass("com.gubby.MyTest");
//Run test
JUnitCore junit = new JUnitCore();
junit.run(testCls); //Throws java.lang.Exception: No runnable methods

En regardant la trace de la pile:

java.lang.Exception: No runnable methods
at org.junit.runners.BlockJUnit4ClassRunner.validateInstanceMethods(BlockJUnit4ClassRunner.java:169)
at org.junit.runners.BlockJUnit4ClassRunner.collectInitializationErrors(BlockJUnit4ClassRunner.java:104)
at org.junit.runners.ParentRunner.validate(ParentRunner.java:355)
at org.junit.runners.ParentRunner.<init>(ParentRunner.java:76)
at org.junit.runners.BlockJUnit4ClassRunner.<init>(BlockJUnit4ClassRunner.java:57)
at org.junit.internal.builders.JUnit4Builder.runnerForClass(JUnit4Builder.java:10)
at org.junit.runners.model.RunnerBuilder.safeRunnerForClass(RunnerBuilder.java:59)
at org.junit.internal.builders.AllDefaultPossibilitiesBuilder.runnerForClass(AllDefaultPossibilitiesBuilder.java:26)
at org.junit.runners.model.RunnerBuilder.safeRunnerForClass(RunnerBuilder.java:59)
at org.junit.internal.requests.ClassRequest.getRunner(ClassRequest.java:26)
at org.junit.runner.JUnitCore.run(JUnitCore.java:138)

Le problème se produit effectivement au BlockJUnit4ClassRunner:169 (en supposant que JUnit 4.11):

https://github.com/junit-team/junit/blob/r4.11/src/main/java/org/junit/runners/BlockJUnit4ClassRunner.java#L95

Où il vérifie que les méthodes annotées avec @Test:

protected List<FrameworkMethod> computeTestMethods() {
return getTestClass().getAnnotatedMethods(Test.class);
}

Dans ce cas, Test.class aura été chargé avec le système chargeur de classe (c'est à dire celui qui a chargé JUnitCore), donc techniquement aucune de vos méthodes d'essai auront été annotés avec cette annotation.

Solution est de charger JUnitCore dans le même chargeur de classe que les tests eux-mêmes.

---

Modifier: En réponse à la question de user3486675, vous devez créer un chargeur de classe qui n'a pas de délégué pour le système de chargeur de classe, par exemple:

private static final class IsolatedURLClassLoader extends URLClassLoader {
private IsolatedURLClassLoader(URL[] urls) {
//Prevent delegation to the system class loader.
super(urls, null);
}
}

Passer cela, un ensemble d'Url qui comprend tout ce dont vous avez besoin. Vous pouvez créer ce par filtrage le système classpath. Notez que vous ne pouvez pas simplement déléguer le chargeur de classe parent, parce que ces classes seraient ensuite chargés par que, plutôt que le chargeur de classe de vos classes de test.

Alors vous avez besoin pour le coup d'envoi de l'ensemble de la JUnit travail à partir d'une classe chargée par ce chargeur de classe. Il obtient en désordre ici. Quelque chose comme ceci totale de la saleté ci-dessous:

public static final class ClassLoaderIsolatedTestRunner {
public ClassLoaderIsolatedTestRunner() {
//Disallow construction at all from wrong ClassLoader
ensureLoadedInIsolatedClassLoader(this);
}
//Do not rename.
public void run_invokedReflectively(List<String> testClasses) throws BuildException {
//Make sure we are not accidentally working in the system CL
ensureLoadedInIsolatedClassLoader(this);
//Load classes
Class<?>[] classes = new Class<?>[testClasses.size()];
for (int i=0; i<testClasses.size(); i++) {
String test = testClasses.get(i);
try {
classes[i] = Class.forName(test);
} catch (ClassNotFoundException e) {
String msg = "Unable to find class file for test ["+test+"]. Make sure all " +
"tests sources are either included in this test target via a 'src' " +
"declaration.";
throw new BuildException(msg, e);
}
}
//Run
JUnitCore junit = new JUnitCore();
ensureLoadedInIsolatedClassLoader(junit);
junit.addListener(...);
junit.run(classes);
}
private static void ensureLoadedInIsolatedClassLoader(Object o) {
String objectClassLoader = o.getClass().getClassLoader().getClass().getName();
//NB: Can't do instanceof here because they are not instances of each other.
if (!objectClassLoader.equals(IsolatedURLClassLoader.class.getName())) {
throw new IllegalStateException(String.format(
"Instance of %s not loaded by a IsolatedURLClassLoader (loaded by %s)",
cls, objectClassLoader));
}
}
}

ENSUITE, vous devez invoquer le coureur via la réflexion:

Class<?> runnerClass = isolatedClassLoader.loadClass(ClassLoaderIsolatedTestRunner.class.getName());
//Invoke via reflection (List.class is OK because it just uses the string form of it)
Object runner = runnerClass.newInstance();
Method method = runner.getClass().getMethod("run_invokedReflectively", List.class);
method.invoke(...);

Mon test du contrôleur en gros raccourci:

@RunWith(SpringRunner.class)
@SpringBootTest
public class TaskControllerTest {
//...
//tests
//
}

J'ai juste enlevé le "public" et comme par magie ça a fonctionné.

Dans Eclipse, j'ai eu à utiliser New > Other > JUnit > Junit Test. Une classe Java créé avec exactement le même texte m'a donné l'erreur, peut-être parce qu'il a été en utilisant JUnit 3.x.