[Core] Classpath scanning inside nested Jars is not supported.

Spring Boot provides an executable jar format that packages the
application and all dependencies into a self contained jar[1]. This
format doesn't follow regular jar layouts making it harder to scan.

Cucumber currently doesn't support this use case and will throw an error
if nested jars are detected. As a work around users can unpack their
application or glue code before executing[2].

 - [1] https://docs.spring.io/spring-boot/docs/current/reference/html/appendix-executable-jar-format.html
 - [2] https://docs.spring.io/autorepo/docs/spring-boot/1.5.10.BUILD-SNAPSHOT/maven-plugin/repackage-mojo.html#requiresUnpack

Author: mpkorstanje

core/src/main/java/io/cucumber/core/resource/ClasspathSupport.java

@@ -84,8 +84,13 @@ static String determinePackageName(Path baseDir, String basePackageName, Path cl
             .collect(joining(PACKAGE_SEPARATOR_STRING));
     }
 
+    private static String determineSubpackageResourceName(Path baseDir, Path resource) {
+        Path relativePath = baseDir.relativize(resource.getParent());
+        return relativePath.toString();
+    }
+
     static String determineFullyQualifiedResourceName(Path baseDir, String packagePath, Path resource) {
-        String subPackageName = determineSubpackageName(baseDir, resource);
+        String subPackageName = determineSubpackageResourceName(baseDir, resource);
         String resourceName = resource.getFileName().toString();
         return of(packagePath, subPackageName, resourceName)
             .filter(value -> !value.isEmpty()) // default package .

core/src/main/java/io/cucumber/core/resource/PathScanner.java

@@ -1,5 +1,6 @@
 package io.cucumber.core.resource;
 
+import io.cucumber.core.exception.CucumberException;
 import io.cucumber.core.logging.Logger;
 import io.cucumber.core.logging.LoggerFactory;
 
@@ -118,7 +119,7 @@ static class JarUriFileSystemService {
         private static final String FILE_URI_SCHEME = "file";
         private static final String JAR_URI_SCHEME = "jar";
         private static final String JAR_URI_SCHEME_PREFIX = JAR_URI_SCHEME + ":";
-        private static final String JAR_FILE_EXTENSION = ".jar";
+        private static final String JAR_FILE_SUFFIX = ".jar";
         private static final String JAR_URI_SEPARATOR = "!";
 
         private static CloseablePath createForJarFileSystem(URI jarUri, Function<FileSystem, Path> pathProvider)
@@ -135,6 +136,9 @@ static boolean supports(URI uri) {
         static CloseablePath create(URI uri) throws URISyntaxException, IOException {
             if (hasJarUriScheme(uri)) {
                 String[] parts = uri.toString().split(JAR_URI_SEPARATOR);
+                if (parts.length > 2) {
+                    throw nestedJarEntriesAreUnsupported(uri);
+                }
                 String jarUri = parts[0];
                 String jarEntry = parts[1];
                 return createForJarFileSystem(new URI(jarUri), fileSystem -> fileSystem.getPath(jarEntry));
@@ -147,8 +151,20 @@ static CloseablePath create(URI uri) throws URISyntaxException, IOException {
             return null;
         }
 
+        private static CucumberException nestedJarEntriesAreUnsupported(URI uri) {
+            return new CucumberException("" +
+                "The resource " + uri + " is located in a nested jar.\n" +
+                "\n" +
+                "This typically happens when trying to run Cucumber inside a Spring Boot Executable Jar.\n" +
+                "Cucumber currently doesn't support classpath scanning in nested jars.\n" +
+                "Feel free to send a pull request to make this possible!\n" +
+                "\n" +
+                "You can avoid this error by unpacking your application or glue code before executing."
+            );
+        }
+
         private static boolean hasFileUriSchemeWithJarExtension(URI uri) {
-            return FILE_URI_SCHEME.equals(uri.getScheme()) && uri.getPath().endsWith(JAR_FILE_EXTENSION);
+            return FILE_URI_SCHEME.equals(uri.getScheme()) && uri.getPath().endsWith(JAR_FILE_SUFFIX);
         }
 
         private static boolean hasJarUriScheme(URI uri) {

core/src/test/java/io/cucumber/core/resource/ClasspathScannerTest.java

@@ -21,7 +21,7 @@ class ClasspathScannerTest {
     @Test
     void scanForSubClassesInPackage() {
         List<Class<? extends ExampleInterface>> classes = scanner.
-            scanForSubClassesInPackage("io.cucumber.core.resource", ExampleInterface.class);
+            scanForSubClassesInPackage("io.cucumber", ExampleInterface.class);
 
         assertThat(classes, contains(ExampleClass.class));
     }

core/src/test/java/io/cucumber/core/resource/ResourceScannerTest.java

@@ -1,15 +1,18 @@
 package io.cucumber.core.resource;
 
+import io.cucumber.core.exception.CucumberException;
 import org.junit.jupiter.api.Test;
 
 import java.io.File;
 import java.net.URI;
 import java.util.List;
 
 import static java.util.Optional.of;
+import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder;
 import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 class ResourceScannerTest {
 
@@ -118,6 +121,33 @@ void scanForResourcesJarUri() {
         assertThat(resources, contains(resourceUri));
     }
 
+
+    @Test
+    void scanForResourcesNestedJarUri() {
+        URI jarFileUri = new File("src/test/resources/io/cucumber/core/resource/test/spring-resource.jar").toURI();
+        URI resourceUri = URI.create("jar:file://" + jarFileUri.getSchemeSpecificPart() + "!/BOOT-INF/lib/jar-resource.jar!/com/example/package-jar-resource.txt");
+
+        CucumberException exception = assertThrows(
+            CucumberException.class,
+            () -> resourceScanner.scanForResourcesUri(resourceUri)
+        );
+        assertThat(exception.getMessage(), containsString("Cucumber currently doesn't support classpath scanning in nested jars."));
+
+    }
+
+    @Test
+    void scanForResourcesNestedJarUriUnPackaged() {
+        URI jarFileUri = new File("src/test/resources/io/cucumber/core/resource/test/spring-resource.jar").toURI();
+        URI resourceUri = URI.create("jar:file://" + jarFileUri.getSchemeSpecificPart() + "!/BOOT-INF/classes!/com/example/");
+
+        CucumberException exception = assertThrows(
+            CucumberException.class,
+            () -> resourceScanner.scanForResourcesUri(resourceUri)
+        );
+        assertThat(exception.getMessage(), containsString("Cucumber currently doesn't support classpath scanning in nested jars."));
+    }
+
+
     @Test
     void scanForResourcesDirectoryUri() {
         File file = new File("src/test/resources/io/cucumber/core/resource");

core/src/test/resources/io/cucumber/core/resource/test/spring-resource.jar

@@ -132,7 +132,7 @@ public Cucumber(Class clazz) throws InitializationError {
             .build(junitEnvironmentOptions);
 
         // Parse the features early. Don't proceed when there are lexer errors
-        Supplier<ClassLoader> classLoader = clazz::getClassLoader;
+        Supplier<ClassLoader> classLoader = Thread.currentThread()::getContextClassLoader;
         FeaturePathFeatureSupplier featureSupplier = new FeaturePathFeatureSupplier(classLoader, runtimeOptions);
         this.features = featureSupplier.get();
 

junit/src/main/java/io/cucumber/junit/Cucumber.java

@@ -82,7 +82,7 @@ public TestNGCucumberRunner(Class clazz) {
             .addDefaultSummaryPrinterIfAbsent()
             .build(environmentOptions);
 
-        Supplier<ClassLoader> classLoader = clazz::getClassLoader;
+        Supplier<ClassLoader> classLoader = Thread.currentThread()::getContextClassLoader;
         featureSupplier = new FeaturePathFeatureSupplier(classLoader, runtimeOptions);
 
         this.bus = new TimeServiceEventBus(Clock.systemUTC());