Warn when selectClasspathResource is incorrectly used

cucumber-junit-platform-engine/src/main/java/io/cucumber/junit/platform/engine/DiscoverySelectorResolver.java

@@ -10,7 +10,7 @@ class DiscoverySelectorResolver {
     private static final EngineDiscoveryRequestResolver<CucumberEngineDescriptor> resolver = EngineDiscoveryRequestResolver
             .<CucumberEngineDescriptor>builder()
             .addResourceContainerSelectorResolver(new IsFeature())
-            .addSelectorResolver(context -> new FeatureResolver(context.getEngineDescriptor().getConfiguration()))
+            .addSelectorResolver(context -> new FeatureResolver(context.getEngineDescriptor().getConfiguration(), context.getPackageFilter()))
             .addTestDescriptorVisitor(context -> new FeatureOrderingVisitor())
             .addTestDescriptorVisitor(context -> new FeatureElementOrderingVisitor())
             .addTestDescriptorVisitor(context -> TestDescriptor::prune)

cucumber-junit-platform-engine/src/main/java/io/cucumber/junit/platform/engine/FeatureResolver.java

@@ -5,6 +5,8 @@
 import io.cucumber.core.feature.FeatureParser;
 import io.cucumber.core.gherkin.Feature;
 import io.cucumber.core.gherkin.Pickle;
+import io.cucumber.core.logging.Logger;
+import io.cucumber.core.logging.LoggerFactory;
 import io.cucumber.core.resource.ClassLoaders;
 import io.cucumber.core.resource.ResourceScanner;
 import io.cucumber.core.runtime.UuidGeneratorServiceLoader;
@@ -33,6 +35,7 @@
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Function;
+import java.util.function.Predicate;
 import java.util.function.Supplier;
 import java.util.stream.Stream;
 
@@ -51,14 +54,17 @@
 import static org.junit.platform.engine.discovery.DiscoverySelectors.selectPackage;
 
 final class FeatureResolver implements SelectorResolver {
+    private static final Logger log = LoggerFactory.getLogger(FeatureResolver.class);
 
     private final ResourceScanner<Feature> featureScanner;
 
     private final CucumberConfiguration configuration;
     private final CachingFeatureParser featureParser;
+    private final Predicate<String> packageFilter;
 
-    FeatureResolver(CucumberConfiguration configuration) {
+    FeatureResolver(CucumberConfiguration configuration, Predicate<String> packageFilter) {
         this.configuration = configuration;
+        this.packageFilter = packageFilter;
         this.featureParser = createFeatureParser(configuration);
         this.featureScanner = new ResourceScanner<>(
             ClassLoaders::getDefaultClassLoader,
@@ -133,11 +139,23 @@ public Resolution resolve(FileSelector selector, Context context) {
     public Resolution resolve(ClasspathResourceSelector selector, Context context) {
         Set<Resource> resources = selector.getClasspathResources();
         if (!resources.stream().allMatch(isFeature)) {
-            return Resolution.unresolved();
+            Set<DiscoverySelector> selectors = featureScanner
+                    .scanForClasspathResource(selector.getClasspathResourceName(), packageFilter)
+                    .stream()
+                    .map(feature -> selector.getPosition()
+                            .map(position -> selectElementAt(feature, position))
+                            .orElseGet(() -> Optional.of(selectFeature(feature))))
+                    .filter(Optional::isPresent)
+                    .map(Optional::get)
+                    .collect(toSet());
+
+            warnClasspathResourceSelectorUsedForPackage(selector);
+
+            return toResolution(selectors);
         }
         if (resources.size() > 1) {
             throw new IllegalArgumentException(String.format(
-                "Found %s resources named %s classpath %s. Using the first.",
+                "Found %s resources named %s on the classpath %s.",
                 resources.size(), selector.getClasspathResourceName(),
                 resources.stream().map(Resource::getUri).collect(toList())));
         }
@@ -154,6 +172,17 @@ public Resolution resolve(ClasspathResourceSelector selector, Context context) {
                 .orElseGet(Resolution::unresolved);
     }
 
+    private static void warnClasspathResourceSelectorUsedForPackage(ClasspathResourceSelector selector) {
+        log.warn(() -> {
+            String classpathResourceName = selector.getClasspathResourceName();
+            String packageName = classpathResourceName.replaceAll("/", ".");
+            return String.format(
+                "The classpath resource selector '%s' should not be used to select features in a package. Use the package selector with '%s' instead",
+                classpathResourceName,
+                packageName);
+        });
+    }
+
     @Override
     public Resolution resolve(UriSelector selector, Context context) {
         URI uri = selector.getUri();

cucumber-junit-platform-engine/src/test/java/io/cucumber/junit/platform/engine/CucumberTestEngineTest.java

@@ -149,7 +149,34 @@ void supportsClasspathResourceSelector() {
     }
 
     @Test
-    void supportsClasspathResourceSelectorThrowIfDuplicateResources() {
+    void warnWhenResourceSelectorIsUsedToSelectAPackage(LogRecordListener logRecordListener) {
+        EngineTestKit.engine(ENGINE_ID)
+                .selectors(selectClasspathResource("io/cucumber/junit/platform/engine"))
+                .execute()
+                .allEvents()
+                .assertEventsMatchLooselyInOrder(
+                    feature("disabled.feature"),
+                    feature("empty-scenario.feature"),
+                    feature("scenario-outline.feature"),
+                    feature("rule.feature"),
+                    feature("single.feature"),
+                    feature("with%20space.feature"));
+
+        LogRecord warning = logRecordListener.getLogRecords()
+                .stream()
+                .filter(logRecord -> FeatureResolver.class.getName().equals(logRecord.getLoggerName()))
+                .filter(logRecord -> Level.WARNING.equals(logRecord.getLevel()))
+                .findFirst().get();
+
+        assertThat(warning.getMessage())
+                .isEqualTo(
+                    "The classpath resource selector 'io/cucumber/junit/platform/engine' should not be " +
+                            "used to select features in a package. Use the package selector with " +
+                            "'io.cucumber.junit.platform.engine' instead");
+    }
+
+    @Test
+    void classpathResourceSelectorThrowIfDuplicateResources() {
         class TestResource implements Resource {
 
             private final String name;
@@ -190,7 +217,7 @@ public URI getUri() {
         assertThat(exception) //
                 .hasRootCauseInstanceOf(IllegalArgumentException.class) //
                 .hasRootCauseMessage( //
-                    "Found %s resources named %s classpath %s. Using the first.", //
+                    "Found %s resources named %s on the classpath %s.", //
                     resources.size(), //
                     "io/cucumber/junit/platform/engine/single.feature", //
                     resources.stream().map(Resource::getUri).collect(toList()));

cucumber-junit-platform-engine/src/test/java/io/cucumber/junit/platform/engine/FeatureResolverTest.java

@@ -36,7 +36,8 @@ class FeatureResolverTest {
     private TestDescriptor getFeature() {
         EngineDiscoveryRequestResolver<CucumberEngineDescriptor> resolver = EngineDiscoveryRequestResolver
                 .<CucumberEngineDescriptor> builder()
-                .addSelectorResolver(context -> new FeatureResolver(new CucumberConfiguration(configurationParameters)))
+                .addSelectorResolver(context -> new FeatureResolver(new CucumberConfiguration(configurationParameters),
+                    context.getPackageFilter()))
                 .addTestDescriptorVisitor(context -> new FeatureElementOrderingVisitor())
                 .build();
         resolver.resolve(new SelectorRequest(selectClasspathResource(featurePath)), engineDescriptor);