[Core] Share object factory between backends

By sharing the object factory between different backends it becomes
possible to use the same test context in different languages. This is
very useful when mixing Kotlin and Java, or Java and Java 8.

This also requires that the backend no longer manages the object factory
life-cycle. To end a container and lookup have been extracted from the
object factory.

Closes #1117.

Author: mpkorstanje

core/src/main/java/io/cucumber/core/backend/BackendProviderService.java

@@ -5,6 +5,6 @@
 
 public interface BackendProviderService {
 
-    Backend create(ObjectFactory objectFactory, ResourceLoader resourceLoader, TypeRegistry typeRegistry);
+    Backend create(Container container, ResourceLoader resourceLoader, TypeRegistry typeRegistry);
 
 }

core/src/main/java/io/cucumber/core/backend/Container.java

@@ -0,0 +1,11 @@
+package io.cucumber.core.backend;
+
+public interface Container extends Lookup {
+    /**
+     * Collects glue classes in the classpath. Called once on init.
+     *
+     * @param glueClass Glue class containing cucumber.api annotations (Before, Given, When, ...)
+     * @return true if stepdefs and hooks in this class should be used, false if they should be ignored.
+     */
+    boolean addClass(Class<?> glueClass);
+}

core/src/main/java/io/cucumber/core/backend/Lookup.java

@@ -0,0 +1,12 @@
+package io.cucumber.core.backend;
+
+public interface Lookup {
+    /**
+     * Provides the glue instances used to execute the current scenario.
+     *
+     * @param glueClass type of instance to be created.
+     * @param <T>       type of Glue class
+     * @return new Glue instance of type T
+     */
+    <T> T getInstance(Class<T> glueClass);
+}

core/src/main/java/io/cucumber/core/backend/ObjectFactory.java

@@ -3,7 +3,7 @@
 /**
  * Minimal facade for Dependency Injection containers
  */
-public interface ObjectFactory {
+public interface ObjectFactory extends Container {
 
     /**
      * Instantiate glue code <b>before</b> scenario execution. Called once per scenario.
@@ -15,21 +15,4 @@ public interface ObjectFactory {
      */
     void stop();
 
-    /**
-     * Collects glue classes in the classpath. Called once on init.
-     *
-     * @param glueClass Glue class containing cucumber.api annotations (Before, Given, When, ...)
-     * @return true if stepdefs and hooks in this class should be used, false if they should be ignored.
-     */
-    boolean addClass(Class<?> glueClass);
-
-    /**
-     * Provides the glue instances used to execute the current scenario. The instance can be prepared in
-     * {@link #start()}.
-     *
-     * @param glueClass type of instance to be created.
-     * @param <T>       type of Glue class
-     * @return new Glue instance of type T
-     */
-    <T> T getInstance(Class<T> glueClass);
 }

core/src/main/java/io/cucumber/core/backend/ObjectFactorySupplier.java

@@ -0,0 +1,7 @@
+package io.cucumber.core.backend;
+
+public interface ObjectFactorySupplier {
+
+    ObjectFactory get();
+
+}

core/src/main/java/io/cucumber/core/backend/SingletonObjectFactorySupplier.java

@@ -0,0 +1,18 @@
+package io.cucumber.core.backend;
+
+import io.cucumber.core.options.Env;
+
+import static io.cucumber.core.backend.ObjectFactoryLoader.loadObjectFactory;
+
+public class SingletonObjectFactorySupplier implements ObjectFactorySupplier {
+
+    private ObjectFactory objectFactory;
+
+    @Override
+    public ObjectFactory get() {
+        if(objectFactory == null){
+            objectFactory = loadObjectFactory(Env.INSTANCE.get(ObjectFactory.class.getName()));
+        }
+        return objectFactory;
+    }
+}

core/src/main/java/io/cucumber/core/backend/ThreadLocalObjectFactorySupplier.java

@@ -0,0 +1,18 @@
+package io.cucumber.core.backend;
+
+
+import io.cucumber.core.options.Env;
+
+import static io.cucumber.core.backend.ObjectFactoryLoader.loadObjectFactory;
+
+public class ThreadLocalObjectFactorySupplier implements ObjectFactorySupplier {
+
+    private final ThreadLocal<ObjectFactory> runners = ThreadLocal.withInitial(
+        () -> loadObjectFactory(Env.INSTANCE.get(ObjectFactory.class.getName()))
+    );
+
+    @Override
+    public ObjectFactory get() {
+        return runners.get();
+    }
+}

core/src/main/java/io/cucumber/core/runner/Runner.java

@@ -8,6 +8,7 @@
 import gherkin.pickles.PickleTag;
 import io.cucumber.core.backend.Backend;
 import io.cucumber.core.backend.HookDefinition;
+import io.cucumber.core.backend.ObjectFactory;
 import io.cucumber.core.event.EventBus;
 import io.cucumber.core.logging.Logger;
 import io.cucumber.core.logging.LoggerFactory;
@@ -27,11 +28,13 @@ public final class Runner {
     private final EventBus bus;
     private final Collection<? extends Backend> backends;
     private final RunnerOptions runnerOptions;
+    private final ObjectFactory objectFactory;
 
-    public Runner(EventBus bus, Collection<? extends Backend> backends, RunnerOptions runnerOptions) {
+    public Runner(EventBus bus, Collection<? extends Backend> backends, ObjectFactory objectFactory, RunnerOptions runnerOptions) {
         this.bus = bus;
         this.runnerOptions = runnerOptions;
         this.backends = backends;
+        this.objectFactory = objectFactory;
         List<URI> gluePaths = runnerOptions.getGlue();
         log.debug("Loading glue from " + FixJava.join(gluePaths, ", "));
         for (Backend backend : backends) {
@@ -49,7 +52,6 @@ public void runPickle(PickleEvent pickle) {
         TestCase testCase = createTestCaseForPickle(pickle);
         testCase.run(bus);
         disposeBackendWorlds();
-        glue.removeScenarioScopedGlue();
     }
 
     public void reportStepDefinitions(StepDefinitionReporter stepDefinitionReporter) {
@@ -127,6 +129,7 @@ private List<HookTestStep> getBeforeStepHooks(List<PickleTag> tags) {
     }
 
     private void buildBackendWorlds() {
+        objectFactory.start();
         for (Backend backend : backends) {
             backend.buildWorld();
         }
@@ -136,5 +139,7 @@ private void disposeBackendWorlds() {
         for (Backend backend : backends) {
             backend.disposeWorld();
         }
+        objectFactory.stop();
+        glue.removeScenarioScopedGlue();
     }
 }

core/src/main/java/io/cucumber/core/runtime/BackendServiceLoader.java

@@ -4,11 +4,11 @@
 import io.cucumber.core.backend.Backend;
 import io.cucumber.core.backend.BackendProviderService;
 import io.cucumber.core.backend.BackendSupplier;
-import io.cucumber.core.backend.ObjectFactory;
+import io.cucumber.core.backend.Container;
+import io.cucumber.core.backend.ObjectFactorySupplier;
 import io.cucumber.core.exception.CucumberException;
 import io.cucumber.core.io.ClassFinder;
 import io.cucumber.core.io.ResourceLoader;
-import io.cucumber.core.options.Env;
 import io.cucumber.core.options.RuntimeOptions;
 import io.cucumber.core.reflection.Reflections;
 import io.cucumber.core.stepexpression.TypeRegistry;
@@ -19,8 +19,6 @@
 import java.util.Locale;
 import java.util.ServiceLoader;
 
-import static io.cucumber.core.backend.ObjectFactoryLoader.loadObjectFactory;
-
 /**
  * Supplies instances of {@link Backend} created by using a {@link ServiceLoader}
  * to locate instance of {@link BackendSupplier}.
@@ -30,11 +28,13 @@ public final class BackendServiceLoader implements BackendSupplier {
     private final ResourceLoader resourceLoader;
     private final ClassFinder classFinder;
     private final RuntimeOptions runtimeOptions;
+    private final ObjectFactorySupplier container;
 
-    public BackendServiceLoader(ResourceLoader resourceLoader, ClassFinder classFinder, RuntimeOptions runtimeOptions) {
+    public BackendServiceLoader(ResourceLoader resourceLoader, ClassFinder classFinder, RuntimeOptions runtimeOptions, ObjectFactorySupplier container) {
         this.resourceLoader = resourceLoader;
         this.classFinder = classFinder;
         this.runtimeOptions = runtimeOptions;
+        this.container = container;
     }
 
     @Override
@@ -54,8 +54,7 @@ private Collection<? extends Backend> loadBackends(Iterable<BackendProviderServi
         final TypeRegistry typeRegistry = createTypeRegistry();
         List<Backend> backends = new ArrayList<>();
         for (BackendProviderService backendProviderService : serviceLoader) {
-            ObjectFactory objectFactory = loadObjectFactory(Env.INSTANCE.get(ObjectFactory.class.getName()));
-            backends.add(backendProviderService.create(objectFactory, resourceLoader, typeRegistry));
+            backends.add(backendProviderService.create(container.get(), resourceLoader, typeRegistry));
         }
         return backends;
     }

core/src/main/java/io/cucumber/core/runtime/Runtime.java

@@ -11,6 +11,10 @@
 import io.cucumber.core.api.event.TestRunFinished;
 import io.cucumber.core.api.event.TestRunStarted;
 import io.cucumber.core.backend.BackendSupplier;
+import io.cucumber.core.backend.ObjectFactory;
+import io.cucumber.core.backend.ObjectFactorySupplier;
+import io.cucumber.core.backend.SingletonObjectFactorySupplier;
+import io.cucumber.core.backend.ThreadLocalObjectFactorySupplier;
 import io.cucumber.core.exception.CucumberException;
 import io.cucumber.core.event.EventBus;
 import io.cucumber.core.options.Env;
@@ -38,6 +42,7 @@
 import java.util.concurrent.TimeUnit;
 
 import static io.cucumber.core.api.event.Result.SEVERITY;
+import static io.cucumber.core.backend.ObjectFactoryLoader.loadObjectFactory;
 import static java.util.Collections.emptyList;
 import static java.util.Collections.max;
 import static java.util.Collections.min;
@@ -190,9 +195,13 @@ public Runtime build() {
                 ? this.classFinder
                 : new ResourceLoaderClassFinder(resourceLoader, this.classLoader);
 
+            final ObjectFactorySupplier objectFactorySupplier = runtimeOptions.isMultiThreaded()
+                ? new ThreadLocalObjectFactorySupplier()
+                : new SingletonObjectFactorySupplier();
+
             final BackendSupplier backendSupplier = this.backendSupplier != null
                 ? this.backendSupplier
-                : new BackendServiceLoader(resourceLoader, classFinder, runtimeOptions);
+                : new BackendServiceLoader(resourceLoader, classFinder, runtimeOptions, objectFactorySupplier);
 
             final Plugins plugins = new Plugins(new PluginFactory(), this.eventBus, runtimeOptions);
             for (final Plugin plugin : additionalPlugins) {
@@ -202,8 +211,8 @@ public Runtime build() {
             plugins.addPlugin(exitStatus);
 
             final RunnerSupplier runnerSupplier = runtimeOptions.isMultiThreaded()
-                ? new ThreadLocalRunnerSupplier(runtimeOptions, eventBus, backendSupplier)
-                : new SingletonRunnerSupplier(runtimeOptions, eventBus, backendSupplier);
+                ? new ThreadLocalRunnerSupplier(runtimeOptions, eventBus, backendSupplier, objectFactorySupplier)
+                : new SingletonRunnerSupplier(runtimeOptions, eventBus, backendSupplier, objectFactorySupplier);
 
             final ExecutorService executor = runtimeOptions.isMultiThreaded()
                 ? Executors.newFixedThreadPool(runtimeOptions.getThreads())

core/src/main/java/io/cucumber/core/runtime/SingletonRunnerSupplier.java

@@ -1,6 +1,8 @@
 package io.cucumber.core.runtime;
 
 import io.cucumber.core.backend.BackendSupplier;
+import io.cucumber.core.backend.ObjectFactory;
+import io.cucumber.core.backend.ObjectFactorySupplier;
 import io.cucumber.core.event.EventBus;
 import io.cucumber.core.options.RunnerOptions;
 import io.cucumber.core.runner.Runner;
@@ -15,17 +17,19 @@ public final class SingletonRunnerSupplier implements RunnerSupplier {
     private final BackendSupplier backendSupplier;
     private final RunnerOptions runnerOptions;
     private final EventBus eventBus;
+    private final ObjectFactorySupplier objectFactory;
     private Runner runner;
 
 
     public SingletonRunnerSupplier(
         RunnerOptions runnerOptions,
         EventBus eventBus,
-        BackendSupplier backendSupplier
-    ) {
+        BackendSupplier backendSupplier,
+        ObjectFactorySupplier objectFactory) {
         this.backendSupplier = backendSupplier;
         this.runnerOptions = runnerOptions;
         this.eventBus = eventBus;
+        this.objectFactory = objectFactory;
     }
 
     @Override
@@ -37,7 +41,7 @@ public Runner get() {
     }
 
     private Runner createRunner() {
-        return new Runner(eventBus, backendSupplier.get(), runnerOptions);
+        return new Runner(eventBus, backendSupplier.get(), objectFactory.get(), runnerOptions);
     }
 
 }

core/src/main/java/io/cucumber/core/runtime/ThreadLocalRunnerSupplier.java

@@ -3,6 +3,8 @@
 import io.cucumber.core.api.event.Event;
 import io.cucumber.core.api.event.EventHandler;
 import io.cucumber.core.backend.BackendSupplier;
+import io.cucumber.core.backend.ObjectFactory;
+import io.cucumber.core.backend.ObjectFactorySupplier;
 import io.cucumber.core.event.AbstractEventBus;
 import io.cucumber.core.event.EventBus;
 import io.cucumber.core.options.RunnerOptions;
@@ -18,22 +20,19 @@ public final class ThreadLocalRunnerSupplier implements RunnerSupplier {
     private final BackendSupplier backendSupplier;
     private final RunnerOptions runnerOptions;
     private final SynchronizedEventBus sharedEventBus;
+    private final ObjectFactorySupplier objectFactory;
 
-    private final ThreadLocal<Runner> runners = new ThreadLocal<Runner>() {
-        @Override
-        protected Runner initialValue() {
-            return createRunner();
-        }
-    };
+    private final ThreadLocal<Runner> runners = ThreadLocal.withInitial(this::createRunner);
 
     public ThreadLocalRunnerSupplier(
         RunnerOptions runnerOptions,
         EventBus sharedEventBus,
-        BackendSupplier backendSupplier
-    ) {
+        BackendSupplier backendSupplier,
+        ObjectFactorySupplier objectFactory) {
         this.runnerOptions = runnerOptions;
         this.sharedEventBus = SynchronizedEventBus.synchronize(sharedEventBus);
         this.backendSupplier = backendSupplier;
+        this.objectFactory = objectFactory;
     }
 
     @Override
@@ -42,7 +41,7 @@ public Runner get() {
     }
 
     private Runner createRunner() {
-        return new Runner(new LocalEventBus(sharedEventBus), backendSupplier.get(), runnerOptions);
+        return new Runner(new LocalEventBus(sharedEventBus), backendSupplier.get(), objectFactory.get(), runnerOptions);
     }
 
     private static final class LocalEventBus extends AbstractEventBus {

core/src/test/java/io/cucumber/core/backend/StubBackendProviderService.java

@@ -12,7 +12,7 @@
 
 public class StubBackendProviderService implements BackendProviderService {
     @Override
-    public Backend create(ObjectFactory objectFactory, ResourceLoader resourceLoader, TypeRegistry typeRegistry) {
+    public Backend create(Container container, ResourceLoader resourceLoader, TypeRegistry typeRegistry) {
         return new StubBackend();
     }
 

core/src/test/java/io/cucumber/core/runner/HookTest.java

@@ -4,6 +4,7 @@
 import io.cucumber.core.backend.Glue;
 import io.cucumber.core.backend.HookDefinition;
 import io.cucumber.core.backend.Backend;
+import io.cucumber.core.backend.ObjectFactory;
 import io.cucumber.core.event.EventBus;
 import io.cucumber.core.io.MultiLoader;
 import io.cucumber.core.options.Env;
@@ -47,6 +48,7 @@ public class HookTest {
     public void after_hooks_execute_before_objects_are_disposed() throws Throwable {
 
         Backend backend = mock(Backend.class);
+        ObjectFactory objectFactory = mock(ObjectFactory.class);
         final HookDefinition hook = mock(HookDefinition.class);
         when(hook.matches(ArgumentMatchers.<PickleTag>anyCollection())).thenReturn(true);
 
@@ -59,7 +61,7 @@ public Object answer(InvocationOnMock invocation) {
             }
         }).when(backend).loadGlue(any(Glue.class), ArgumentMatchers.<URI>anyList());
 
-        Runner runner = new Runner(bus, Collections.singleton(backend), runtimeOptions);
+        Runner runner = new Runner(bus, Collections.singleton(backend), objectFactory, runtimeOptions);
 
         runner.runPickle(pickleEvent);