[Spring] Share application context

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

@@ -26,8 +26,6 @@
 import java.util.Set;
 
 import static io.cucumber.spring.CucumberTestContext.SCOPE_CUCUMBER_GLUE;
-import static io.cucumber.spring.FixBootstrapUtils.createBootstrapContext;
-import static io.cucumber.spring.FixBootstrapUtils.resolveTestContextBootstrapper;
 import static java.util.Arrays.asList;
 
 /**
@@ -65,6 +63,8 @@
 @API(status = API.Status.STABLE)
 public final class SpringFactory implements ObjectFactory {
 
+    private static final Object monitor = new Object();
+
     private ConfigurableListableBeanFactory beanFactory;
     private CucumberTestContextManager testContextManager;
 
@@ -129,21 +129,28 @@ private static boolean hasAnnotation(Annotation annotation, Collection<Class<? e
 
     @Override
     public void start() {
-        if (stepClassWithSpringContext != null) {
-            testContextManager = new CucumberTestContextManager(stepClassWithSpringContext);
-        } else {
-            if (beanFactory == null) {
-                beanFactory = createFallbackContext();
+        // registerStepClassBeanDefinition and
+        // CucumberTestContextManager.registerGlueCodeScope manipulate the the
+        // application context. These operations are not thread-safe. So the
+        // SpringFactory must be started serially.
+        synchronized (monitor) {
+            if (stepClassWithSpringContext != null) {
+                testContextManager = new CucumberTestContextManager(stepClassWithSpringContext);
+            } else {
+                if (beanFactory == null) {
+                    beanFactory = createFallbackContext();
+                }
             }
-        }
-        notifyContextManagerAboutTestClassStarted();
-        if (beanFactory == null || isNewContextCreated()) {
-            beanFactory = testContextManager.getBeanFactory();
-            for (Class<?> stepClass : stepClasses) {
-                registerStepClassBeanDefinition(beanFactory, stepClass);
+            notifyContextManagerAboutTestClassStarted();
+            if (beanFactory == null || isNewContextCreated()) {
+                beanFactory = testContextManager.getBeanFactory();
+                for (Class<?> stepClass : stepClasses) {
+                    registerStepClassBeanDefinition(beanFactory, stepClass);
+                }
             }
+            GlueCodeContext.getInstance().start();
         }
-        GlueCodeContext.getInstance().start();
+
     }
 
     @SuppressWarnings("resource")
@@ -183,9 +190,9 @@ private boolean isNewContextCreated() {
     private void registerStepClassBeanDefinition(ConfigurableListableBeanFactory beanFactory, Class<?> stepClass) {
         BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
         BeanDefinition beanDefinition = BeanDefinitionBuilder
-                .genericBeanDefinition(stepClass)
-                .setScope(SCOPE_CUCUMBER_GLUE)
-                .getBeanDefinition();
+            .genericBeanDefinition(stepClass)
+            .setScope(SCOPE_CUCUMBER_GLUE)
+            .getBeanDefinition();
         registry.registerBeanDefinition(stepClass.getName(), beanDefinition);
     }
 
@@ -233,9 +240,7 @@ private static boolean annotatedWithSupportedSpringRootTestAnnotations(Annotatio
     static class CucumberTestContextManager extends TestContextManager {
 
         CucumberTestContextManager(Class<?> testClass) {
-            // Does the same as TestContextManager(Class<?>) but creates a
-            // DefaultCacheAwareContextLoaderDelegate that uses a thread local contextCache.
-            super(resolveTestContextBootstrapper(createBootstrapContext(testClass)));
+            super(testClass);
             registerGlueCodeScope(getContext());
         }
 

spring/src/test/java/io/cucumber/spring/threading/RunParallelCukesTest.java → spring/src/test/java/io/cucumber/spring/threading/RunParallelCucumberTest.java

@@ -1,21 +1,23 @@
 package io.cucumber.spring.threading;
 
 import io.cucumber.core.cli.Main;
-import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.RepeatedTest;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
 
 import static java.util.concurrent.Executors.newFixedThreadPool;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertAll;
 
-class RunParallelCukesTest {
+class RunParallelCucumberTest {
 
-    @Test
-    void test() {
+    @RepeatedTest(100)
+    void test() throws ExecutionException, InterruptedException {
         Callable<Byte> runCucumber = () -> {
             ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
             String[] args = {
@@ -27,14 +29,16 @@ void test() {
         };
 
 
-        ExecutorService executorService = newFixedThreadPool(2);
-        Future<Byte> result1 = executorService.submit(runCucumber);
-        Future<Byte> result2 = executorService.submit(runCucumber);
+        ExecutorService executorService = newFixedThreadPool(ThreadingStepDefs.concurrency);
+        List<Future<Byte>> results = new ArrayList<>();
+        for (int i = 0; i < ThreadingStepDefs.concurrency; i++) {
+            results.add(executorService.submit(runCucumber));
+        }
 
-        assertAll("jobs completed successfully",
-            () -> assertThat(result1.get(), is((byte) 0x0)),
-            () -> assertThat(result2.get(), is((byte) 0x0))
-        );
+        for (Future<Byte> result : results) {
+            assertThat(result.get(), is((byte) 0x0));
+        }
+        ThreadingStepDefs.map.clear();
     }
 
 }

spring/src/test/java/io/cucumber/spring/threading/ThreadingStepDefs.java

@@ -20,7 +20,8 @@
 @ContextConfiguration("classpath:cucumber.xml")
 public class ThreadingStepDefs {
 
-    private static final ConcurrentHashMap<Thread, ThreadingStepDefs> map = new ConcurrentHashMap<>();
+    static final int concurrency = 100;
+    static final ConcurrentHashMap<Thread, ThreadingStepDefs> map = new ConcurrentHashMap<>();
 
     private static final CountDownLatch latch = new CountDownLatch(2);
 
@@ -43,6 +44,6 @@ public void iShouldNotBeSharedBetweenThreads() {
                 assertNotSame(entries.getValue(), this);
             }
         }
-        assertEquals(2, map.size());
+        assertEquals(concurrency, map.size());
     }
 }