[Java] Process glue classes distinctly (#2582)

Users may provide glue paths where one is a strict subset of hte other.
For example:

```
com.example
com.example.app
```

Cucumber would scan both packages (and sub packages), and for each process the
classes it discovered. This would result in the classes from the `app` package
being processed twice.

Fixes: #2581

Author: mpkorstanje

CHANGELOG.md

@@ -16,6 +16,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ### Removed
 
 ### Fixed
+ - [Java] Process glue classes distinctly ([#2582](https://github.com/cucumber/cucumber-jvm/pull/2582) M.P. Korstanje)
 
 ## [7.4.1] (2022-06-23)
 

guice/src/main/java/io/cucumber/guice/GuiceBackend.java

@@ -32,6 +32,7 @@ public void loadGlue(Glue glue, List<URI> gluePaths) {
                 .map(classFinder::scanForClassesInPackage)
                 .flatMap(Collection::stream)
                 .filter(InjectorSource.class::isAssignableFrom)
+                .distinct()
                 .forEach(container::addClass);
     }
 

guice/src/test/java/io/cucumber/guice/GuiceBackendTest.java

@@ -13,12 +13,14 @@
 import java.util.function.Supplier;
 
 import static java.lang.Thread.currentThread;
+import static java.util.Arrays.asList;
 import static java.util.Collections.singletonList;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.notNullValue;
 import static org.hamcrest.Matchers.nullValue;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
 @ExtendWith({ MockitoExtension.class })
@@ -39,6 +41,14 @@ void finds_injector_source_impls_by_classpath_url() {
         verify(factory).addClass(YourInjectorSource.class);
     }
 
+    @Test
+    void finds_injector_source_impls_once_by_classpath_url() {
+        GuiceBackend backend = new GuiceBackend(factory, classLoader);
+        backend.loadGlue(glue, asList(URI.create("classpath:io/cucumber/guice/integration"),
+            URI.create("classpath:io/cucumber/guice/integration")));
+        verify(factory, times(1)).addClass(YourInjectorSource.class);
+    }
+
     @Test
     void world_and_snippet_methods_do_nothing() {
         GuiceBackend backend = new GuiceBackend(factory, classLoader);

java/src/main/java/io/cucumber/java/JavaBackend.java

@@ -37,6 +37,7 @@ public void loadGlue(Glue glue, List<URI> gluePaths) {
                 .map(ClasspathSupport::packageName)
                 .map(classFinder::scanForClassesInPackage)
                 .flatMap(Collection::stream)
+                .distinct()
                 .forEach(aGlueClass -> scan(aGlueClass, (method, annotation) -> {
                     container.addClass(method.getDeclaringClass());
                     glueAdaptor.addDefinition(method, annotation);

java/src/test/java/io/cucumber/java/JavaBackendTest.java

@@ -14,6 +14,7 @@
 import org.mockito.junit.jupiter.MockitoExtension;
 
 import java.net.URI;
+import java.util.Arrays;
 import java.util.List;
 
 import static java.lang.Thread.currentThread;
@@ -27,7 +28,7 @@
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
-@ExtendWith({ MockitoExtension.class })
+@ExtendWith(MockitoExtension.class)
 class JavaBackendTest {
 
     @Captor
@@ -53,6 +54,14 @@ void finds_step_definitions_by_classpath_url() {
         verify(factory).addClass(Steps.class);
     }
 
+    @Test
+    void finds_step_definitions_once_by_classpath_url() {
+        backend.loadGlue(glue,
+            asList(URI.create("classpath:io/cucumber/java/steps"), URI.create("classpath:io/cucumber/java/steps")));
+        backend.buildWorld();
+        verify(factory, times(1)).addClass(Steps.class);
+    }
+
     @Test
     void detects_subclassed_glue_and_throws_exception() {
         Executable testMethod = () -> backend.loadGlue(glue, asList(URI.create("classpath:io/cucumber/java/steps"),

java8/src/main/java/io/cucumber/java8/Java8Backend.java

@@ -48,6 +48,7 @@ public void loadGlue(Glue glue, List<URI> gluePaths) {
                 .flatMap(Collection::stream)
                 .filter(glueClass -> !glueClass.isInterface())
                 .filter(glueClass -> glueClass.getConstructors().length > 0)
+                .distinct()
                 .forEach(glueClass -> {
                     container.addClass(glueClass);
                     lambdaGlueClasses.add(glueClass);

java8/src/test/java/io/cucumber/java8/Java8BackendTest.java

@@ -10,12 +10,15 @@
 import org.mockito.junit.jupiter.MockitoExtension;
 
 import java.net.URI;
+import java.util.Arrays;
 
 import static java.lang.Thread.currentThread;
+import static java.util.Arrays.asList;
 import static java.util.Collections.singletonList;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
-@ExtendWith({ MockitoExtension.class })
+@ExtendWith(MockitoExtension.class)
 class Java8BackendTest {
 
     @Mock
@@ -38,4 +41,12 @@ void finds_step_definitions_by_classpath_url() {
         verify(factory).addClass(Steps.class);
     }
 
+    @Test
+    void finds_step_definitions_once_by_classpath_url() {
+        backend.loadGlue(glue,
+            asList(URI.create("classpath:io/cucumber/java8/steps"), URI.create("classpath:io/cucumber/java8/steps")));
+        backend.buildWorld();
+        verify(factory, times(1)).addClass(Steps.class);
+    }
+
 }

spring/pom.xml

@@ -18,6 +18,7 @@
         <junit-jupiter.version>5.8.2</junit-jupiter.version>
         <spring.version>5.3.21</spring.version>
         <project.Automatic-Module-Name>io.cucumber.spring</project.Automatic-Module-Name>
+        <mockito.version>4.6.1</mockito.version>
     </properties>
 
     <dependencyManagement>
@@ -109,6 +110,12 @@
             <version>${hamcrest.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-junit-jupiter</artifactId>
+            <version>${mockito.version}</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
 </project>

spring/src/main/java/io/cucumber/spring/SpringBackend.java

@@ -31,7 +31,8 @@ public void loadGlue(Glue glue, List<URI> gluePaths) {
                 .map(ClasspathSupport::packageName)
                 .map(classFinder::scanForClassesInPackage)
                 .flatMap(Collection::stream)
-                .filter((Class clazz) -> clazz.getAnnotation(CucumberContextConfiguration.class) != null)
+                .filter((Class<?> clazz) -> clazz.getAnnotation(CucumberContextConfiguration.class) != null)
+                .distinct()
                 .forEach(container::addClass);
     }
 

spring/src/test/java/io/cucumber/spring/SpringBackendTest.java

@@ -0,0 +1,55 @@
+package io.cucumber.spring;
+
+import io.cucumber.core.backend.Glue;
+import io.cucumber.core.backend.ObjectFactory;
+import io.cucumber.core.backend.StepDefinition;
+import io.cucumber.spring.annotationconfig.AnnotationContextConfiguration;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.net.URI;
+
+import static java.lang.Thread.currentThread;
+import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+@ExtendWith(MockitoExtension.class)
+class SpringBackendTest {
+
+    @Mock
+    private Glue glue;
+
+    @Mock
+    private ObjectFactory factory;
+
+    private SpringBackend backend;
+
+    @BeforeEach
+    void createBackend() {
+        this.backend = new SpringBackend(factory, currentThread()::getContextClassLoader);
+    }
+
+    @Test
+    void finds_annotation_context_configuration_by_classpath_url() {
+        backend.loadGlue(glue, singletonList(URI.create("classpath:io/cucumber/spring/annotationconfig")));
+        backend.buildWorld();
+        verify(factory).addClass(AnnotationContextConfiguration.class);
+    }
+
+    @Test
+    void finds_annotaiton_context_configuration_once_by_classpath_url() {
+        backend.loadGlue(glue, asList(
+            URI.create("classpath:io/cucumber/spring/annotationconfig"),
+            URI.create("classpath:io/cucumber/spring/annotationconfig")));
+        backend.buildWorld();
+        verify(factory, times(1)).addClass(AnnotationContextConfiguration.class);
+    }
+
+}