[Spring] Do not share ContextCache between instances of SpringFactory

 The TestContextManager(Class<?>) uses a static ContextCache. This meant
 that all step definitions from all tests would be registered in same context,
 possibly multiple times when running in parallel.

 This is resolved by creating a ThreadLocal ContextCache for each
 SpringFactory.

 Related issues:
  - https://travis-ci.org/cucumber/cucumber-jvm/jobs/244215644
  - #1148

Author: mpkorstanje

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

@@ -1,7 +1,10 @@
 package cucumber.runtime.java.spring;
 
-import cucumber.runtime.CucumberException;
+import static org.springframework.test.context.FixBootstrapUtils.createBootstrapContext;
+import static org.springframework.test.context.FixBootstrapUtils.resolveTestContextBootstrapper;
+
 import cucumber.api.java.ObjectFactory;
+import cucumber.runtime.CucumberException;
 import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
@@ -75,20 +78,20 @@ private void checkAnnotationsEqual(Class<?> stepClassWithSpringContext, Class<?>
         Annotation[] annotations2 = stepClass.getAnnotations();
         if (annotations1.length != annotations2.length) {
             throw new CucumberException("Annotations differs on glue classes found: " +
-                    stepClassWithSpringContext.getName() + ", " +
-                    stepClass.getName());
+                stepClassWithSpringContext.getName() + ", " +
+                stepClass.getName());
         }
         for (Annotation annotation : annotations1) {
             if (!isAnnotationInArray(annotation, annotations2)) {
                 throw new CucumberException("Annotations differs on glue classes found: " +
-                        stepClassWithSpringContext.getName() + ", " +
-                        stepClass.getName());
+                    stepClassWithSpringContext.getName() + ", " +
+                    stepClass.getName());
             }
         }
     }
 
     private boolean isAnnotationInArray(Annotation annotation, Annotation[] annotations) {
-        for (Annotation annotationFromArray: annotations) {
+        for (Annotation annotationFromArray : annotations) {
             if (annotation.equals(annotationFromArray)) {
                 return true;
             }
@@ -152,9 +155,9 @@ private boolean isNewContextCreated() {
     private void registerStepClassBeanDefinition(ConfigurableListableBeanFactory beanFactory, Class<?> stepClass) {
         BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
         BeanDefinition beanDefinition = BeanDefinitionBuilder
-                .genericBeanDefinition(stepClass)
-                .setScope(GlueCodeScope.NAME)
-                .getBeanDefinition();
+            .genericBeanDefinition(stepClass)
+            .setScope(GlueCodeScope.NAME)
+            .getBeanDefinition();
         registry.registerBeanDefinition(stepClass.getName(), beanDefinition);
     }
 
@@ -200,25 +203,28 @@ private boolean annotatedWithSupportedSpringRootTestAnnotations(Class<?> type) {
     }
 }
 
+
 class CucumberTestContextManager extends TestContextManager {
 
-    public CucumberTestContextManager(Class<?> testClass) {
-        super(testClass);
+    CucumberTestContextManager(Class<?> testClass) {
+        // Does the same as TestContextManager(Class<?>) but creates a
+        // DefaultCacheAwareContextLoaderDelegate that does not use a static contextCache.
+        super(resolveTestContextBootstrapper(createBootstrapContext(testClass)));
         registerGlueCodeScope(getContext());
     }
 
-    public ConfigurableListableBeanFactory getBeanFactory() {
+    ConfigurableListableBeanFactory getBeanFactory() {
         return getContext().getBeanFactory();
     }
 
     private ConfigurableApplicationContext getContext() {
-        return (ConfigurableApplicationContext)getTestContext().getApplicationContext();
+        return (ConfigurableApplicationContext) getTestContext().getApplicationContext();
     }
 
     private void registerGlueCodeScope(ConfigurableApplicationContext context) {
         do {
             context.getBeanFactory().registerScope(GlueCodeScope.NAME, new GlueCodeScope());
-            context = (ConfigurableApplicationContext)context.getParent();
+            context = (ConfigurableApplicationContext) context.getParent();
         } while (context != null);
     }
 }

spring/src/main/java/org/springframework/test/context/FixBootstrapUtils.java

@@ -0,0 +1,25 @@
+package org.springframework.test.context;
+
+import org.springframework.test.context.cache.ContextCache;
+import org.springframework.test.context.cache.DefaultCacheAwareContextLoaderDelegate;
+import org.springframework.test.context.cache.DefaultContextCache;
+import org.springframework.test.context.support.DefaultBootstrapContext;
+
+public class FixBootstrapUtils extends BootstrapUtils {
+
+    private static ThreadLocal<ContextCache> contextCache = new ThreadLocal<ContextCache>(){
+        @Override
+        protected ContextCache initialValue() {
+            return new DefaultContextCache();
+        }
+    };
+
+    public static BootstrapContext createBootstrapContext(Class<?> testClass) {
+        CacheAwareContextLoaderDelegate contextLoader = new DefaultCacheAwareContextLoaderDelegate(contextCache.get());
+        return new DefaultBootstrapContext(testClass, contextLoader);
+    }
+
+    public static TestContextBootstrapper resolveTestContextBootstrapper(BootstrapContext bootstrapContext) {
+        return BootstrapUtils.resolveTestContextBootstrapper(bootstrapContext);
+    }
+}