Merge pull request #1148 from cucumber/ishmeister-master

[Spring] Support multithreaded execution of scenarios

Author: mpkorstanje

History.md

@@ -1,5 +1,6 @@
 ## [2.0.0-SNAPSHOT](https://github.com/cucumber/cucumber-jvm/compare/v1.2.5...master) (In Git)
 
+* [Spring] Support multithreaded execution of scenarios ([#1106](https://github.com/cucumber/cucumber-jvm/issues/1106), [#1107](https://github.com/cucumber/cucumber-jvm/issues/1107), [#1148](https://github.com/cucumber/cucumber-jvm/issues/1148) Ismail Bhana, M.P. Korstanje) 
 * [Java8, Kotlin Java8] Support java 8 method references ([#1140](https://github.com/cucumber/cucumber-jvm/pull/1140) M.P. Korstanje) 
 * [Core] Show explicit error message when field name missed in table header ([#1014](https://github.com/cucumber/cucumber-jvm/pull/1014) Mykola Gurov) 
 * [Examples] Properly quit selenium in webbit examples ([#1146](https://github.com/cucumber/cucumber-jvm/pull/1146) Alberto Scotto)

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

@@ -4,14 +4,24 @@
 import java.util.Map;
 
 class GlueCodeContext {
-    public static final GlueCodeContext INSTANCE = new GlueCodeContext();
+
+    private static final ThreadLocal<GlueCodeContext> localContext = new ThreadLocal<GlueCodeContext>() {
+        protected GlueCodeContext initialValue() {
+            return new GlueCodeContext();
+        }
+    };
+
     private final Map<String, Object> objects = new HashMap<String, Object>();
     private final Map<String, Runnable> callbacks = new HashMap<String, Runnable>();
     private int counter;
 
     private GlueCodeContext() {
     }
 
+    public static GlueCodeContext getInstance() {
+        return localContext.get();
+    }
+
     public void start() {
         cleanUp();
         counter++;

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

@@ -6,10 +6,9 @@
 class GlueCodeScope implements Scope {
     public static final String NAME = "cucumber-glue";
 
-    private final GlueCodeContext context = GlueCodeContext.INSTANCE;
-
     @Override
     public Object get(String name, ObjectFactory<?> objectFactory) {
+        GlueCodeContext context = GlueCodeContext.getInstance();
         Object obj = context.get(name);
         if (obj == null) {
             obj = objectFactory.getObject();
@@ -21,11 +20,13 @@ public Object get(String name, ObjectFactory<?> objectFactory) {
 
     @Override
     public Object remove(String name) {
+        GlueCodeContext context = GlueCodeContext.getInstance();
         return context.remove(name);
     }
 
     @Override
     public void registerDestructionCallback(String name, Runnable callback) {
+        GlueCodeContext context = GlueCodeContext.getInstance();
         context.registerDestructionCallback(name, callback);
     }
 
@@ -36,6 +37,7 @@ public Object resolveContextualObject(String key) {
 
     @Override
     public String getConversationId() {
+        GlueCodeContext context = GlueCodeContext.getInstance();
         return context.getId();
     }
 }

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

@@ -112,7 +112,7 @@ public void start() {
                 registerStepClassBeanDefinition(beanFactory, stepClass);
             }
         }
-        GlueCodeContext.INSTANCE.start();
+        GlueCodeContext.getInstance().start();
     }
 
     @SuppressWarnings("resource")
@@ -161,7 +161,7 @@ private void registerStepClassBeanDefinition(ConfigurableListableBeanFactory bea
     @Override
     public void stop() {
         notifyContextManagerAboutTestClassFinished();
-        GlueCodeContext.INSTANCE.stop();
+        GlueCodeContext.getInstance().stop();
     }
 
     private void notifyContextManagerAboutTestClassFinished() {

spring/src/test/java/cucumber/runtime/java/spring/threading/RunParallelCukesTest.java

@@ -0,0 +1,38 @@
+package cucumber.runtime.java.spring.threading;
+
+import static java.util.concurrent.Executors.newFixedThreadPool;
+import static org.junit.Assert.assertEquals;
+
+import cucumber.api.cli.Main;
+import org.junit.Test;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+
+
+public class RunParallelCukesTest {
+
+    private final Callable<Byte> runCuke = new Callable<Byte>() {
+        @Override
+        public Byte call() throws Exception {
+            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
+            String[] args = {
+                "--glue", "cucumber.runtime.java.spring.threading",
+                "classpath:cucumber/runtime/java/spring/threadingCukes.feature",
+                "--strict"
+            };
+            return Main.run(args, classLoader);
+        }
+    };
+
+    @Test
+    public void test() throws InterruptedException, ExecutionException {
+        ExecutorService executorService = newFixedThreadPool(2);
+        Future<Byte> result1 = executorService.submit(runCuke);
+        Future<Byte> result2 = executorService.submit(runCuke);
+        assertEquals(result1.get().byteValue(), 0x0);
+        assertEquals(result2.get().byteValue(), 0x0);
+    }
+}

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

@@ -0,0 +1,48 @@
+package cucumber.runtime.java.spring.threading;
+
+import static java.lang.Thread.currentThread;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertSame;
+
+import cucumber.api.java.en.Given;
+import cucumber.api.java.en.Then;
+import cucumber.api.java.en.When;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.web.WebAppConfiguration;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+@WebAppConfiguration
+@ContextConfiguration("classpath:cucumber.xml")
+public class ThreadingStepDefs {
+
+    private static final ConcurrentHashMap<Thread, ThreadingStepDefs> map = new ConcurrentHashMap<Thread, ThreadingStepDefs>();
+
+    private static final CountDownLatch latch = new CountDownLatch(2);
+
+    @Given("^I am a step definition$")
+    public void iAmAStepDefinition() throws Throwable {
+        map.put(currentThread(), this);
+    }
+
+    @When("^when executed in parallel$")
+    public void whenExecutedInParallel() throws Throwable {
+        latch.await(10, TimeUnit.SECONDS);
+    }
+
+    @Then("^I should not be shared between threads$")
+    public void iShouldNotBeSharedBetweenThreads() throws Throwable {
+        for (Map.Entry<Thread, ThreadingStepDefs> entries : map.entrySet()) {
+            if (entries.getKey().equals(currentThread())) {
+                assertSame(entries.getValue(), this);
+            } else {
+                assertNotSame(entries.getValue(), this);
+            }
+        }
+        assertEquals(2, map.size());
+    }
+}

spring/src/test/resources/cucumber/runtime/java/spring/threadingCukes.feature

@@ -0,0 +1,9 @@
+Feature: Spring Threading Cukes
+  In order to have a completely clean system for each scenario
+  As a purity activist
+  I want that beans have both scenario and thread scope.
+
+  Scenario: A parallel execution
+    Given I am a step definition
+    When when executed in parallel
+    Then I should not be shared between threads