Revise runner tracking to handle threaded execution

Author: sbabcoc

src/main/java/com/nordstrom/automation/junit/CreateTest.java

@@ -27,6 +27,7 @@ public class CreateTest {
 
     private static final Map<Integer, Object> HASHCODE_TO_TARGET = new ConcurrentHashMap<>();
     private static final Map<String, FrameworkMethod> TARGET_TO_METHOD = new ConcurrentHashMap<>();
+    private static final Map<String, Object> TARGET_TO_RUNNER = new ConcurrentHashMap<>();
     private static final ThreadLocal<ConcurrentMap<Integer, DepthGauge>> METHOD_DEPTH;
     private static final Function<Integer, DepthGauge> NEW_INSTANCE;
     private static final Logger LOGGER = LoggerFactory.getLogger(CreateTest.class);
@@ -69,6 +70,7 @@ public static Object intercept(@This final Object runner, @Argument(0) final Fra
             METHOD_DEPTH.get().remove(hashCode);
             LOGGER.debug("testObjectCreated: {}", target);
             TARGET_TO_METHOD.put(toMapKey(target), method);
+            TARGET_TO_RUNNER.put(toMapKey(target), runner);
 
             // apply parameter-based global timeout
             TimeoutUtils.applyTestTimeout(runner, method, target);
@@ -110,6 +112,16 @@ static FrameworkMethod getMethodFor(Object target) {
         return TARGET_TO_METHOD.get(toMapKey(target));
     }
 
+    /**
+     * Get the runner associated with the specified test class instance.
+     * 
+     * @param target test class instance
+     * @return JUnit class runner
+     */
+    static Object getRunnerFor(Object target) {
+        return TARGET_TO_RUNNER.get(toMapKey(target));
+    }
+    
     /**
      * Release the mappings associated with the specified runner/method/target group.
      * 
@@ -121,6 +133,7 @@ static void releaseMappingsFor(Object runner, FrameworkMethod method, Object tar
         HASHCODE_TO_TARGET.remove(Objects.hash(runner, method));
         if (target != null) {
             TARGET_TO_METHOD.remove(toMapKey(target));
+            TARGET_TO_RUNNER.remove(toMapKey(target));
         }
     }
 }

src/main/java/com/nordstrom/automation/junit/RunReflectiveCall.java

@@ -60,19 +60,41 @@ public static Object intercept(@This final ReflectiveCallable callable, @SuperCa
             throws Exception {
 
         Object child = null;
+        Object runner = null;
+        boolean didPush = false;
 
         try {
             // get child object
             child = LifecycleHooks.getFieldValue(callable, "this$0");
+            // get thread runner
+            runner = Run.getThreadRunner();
+            
+            // if runner unknown
+            if (runner == null) {
+                // get runner for child
+                runner = Run.getParentOf(child);
+            }
+            
+            // if runner unknown
+            if (runner == null) {
+                // get test class instance
+                Object target = LifecycleHooks.getFieldValue(callable, "val$target");
+                // if target acquired
+                if (target != null) {
+                    // get runner for target
+                    runner = CreateTest.getRunnerFor(target);
+                    
+                    // if runner resolved
+                    if (runner != null) {
+                        Run.pushThreadRunner(runner);
+                        didPush = true;
+                    }
+                }
+            }
         } catch (IllegalAccessException | NoSuchFieldException | SecurityException | IllegalArgumentException e) {
             // handled below
         }
 
-        Object runner = Run.getParentOf(child);
-        if (runner == null) {
-            runner = Run.getThreadRunner();
-        }
-
         Object result = null;
         Throwable thrown = null;
 
@@ -83,6 +105,9 @@ public static Object intercept(@This final ReflectiveCallable callable, @SuperCa
             thrown = t;
         } finally {
             fireAfterInvocation(runner, child, callable, thrown);
+            if (didPush) {
+                Run.popThreadRunner();
+            }
         }
 
         if (thrown != null) {