Re-implement recording of 'callable' objects (#68)

Author: sbabcoc

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

@@ -18,8 +18,7 @@ public class AtomIdentity extends TestWatcher implements ArtifactParams {
 
     private final Object instance;
     private Description description;
-    private ReflectiveCallable callable;
-    
+
     public AtomIdentity(Object instance) {
         this.instance = instance;
     }
@@ -41,24 +40,6 @@ public Object getInstance() {
         return instance;
     }
 
-    /**
-     * Set the {@link ReflectiveCallable} object for the current test class instance.
-     *  
-     * @param callable {@link ReflectiveCallable} object
-     */
-    public void setCallable(ReflectiveCallable callable) {
-        this.callable = callable;
-    }
-    
-    /**
-     * Get the {@link ReflectiveCallable} object for the current test class instance.
-     *  
-     * @return {@link ReflectiveCallable} object
-     */
-    public ReflectiveCallable getCallable() {
-        return callable;
-    }
-    
     /**
      * {@inheritDoc}
      */

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

@@ -6,6 +6,7 @@
 import java.lang.instrument.Instrumentation;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.util.AbstractList;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -15,6 +16,7 @@
 import java.util.concurrent.ConcurrentMap;
 
 import org.apache.commons.lang3.reflect.MethodUtils;
+import org.junit.internal.runners.model.ReflectiveCallable;
 import org.junit.runner.Description;
 import org.junit.runner.notification.RunListener;
 import org.junit.runners.model.TestClass;
@@ -267,7 +269,35 @@ public static TestClass getTestClassOf(Object runner) {
     public static <T> AtomicTest<T> getAtomicTestOf(Object runner) {
         return RunAnnouncer.getAtomicTestOf(runner);
     }
-    
+
+    /**
+     * Get the {@link ReflectiveCallable} object for the specified class runner or method description.
+     *
+     * @param runner JUnit class runner
+     * @param child JUnit child object (runner or framework method)
+     * @return <b>ReflectiveCallable</b> object (may be {@code null})
+     */
+    public static ReflectiveCallable getCallableOf(Object runner, Object child) {
+        return RunReflectiveCall.getCallableOf(runner, child);
+    }
+
+    /**
+     * Synthesize a {@link ReflectiveCallable} closure with the specified parameters.
+     *
+     * @param method {@link Method} object to be invoked
+     * @param target test class instance to target
+     * @param params method invocation parameters
+     * @return <b>ReflectiveCallable</b> object as specified
+     */
+    public static ReflectiveCallable encloseCallable(final Method method, final Object target, final Object... params) {
+        return new ReflectiveCallable() {
+            @Override
+            protected Object runReflectiveCall() throws Throwable {
+                return method.invoke(target, params);
+            }
+        };
+    }
+
     /**
      * Get the description of the indicated child object from the runner for the specified test class instance.
      * 

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

@@ -91,7 +91,15 @@ public void testAssumptionFailure(Failure failure) {
     @SuppressWarnings({"rawtypes", "unchecked"})
     public void testIgnored(Description description) throws Exception {
         LOGGER.debug("testIgnored: {}", description);
+        // determine if retrying a failed invocation
         AtomicTest<?> atomicTest = getAtomicTestOf(description);
+
+        // if actually ignored
+        if (atomicTest == null) {
+            // create new atomic test object
+            atomicTest = newAtomicTest(description);
+        }
+
         for (RunWatcher watcher : LifecycleHooks.getRunWatchers()) {
             if (isSupported(watcher, atomicTest)) {
                 watcher.testIgnored(atomicTest);

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

@@ -2,10 +2,15 @@
 
 import static com.nordstrom.automation.junit.LifecycleHooks.getFieldValue;
 
+import java.lang.reflect.Method;
+import java.util.Map;
+import java.util.Objects;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.lang.IllegalAccessException;
+
+import com.google.common.base.Optional;
 import org.junit.internal.runners.model.ReflectiveCallable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -23,7 +28,8 @@
  */
 @SuppressWarnings("squid:S1118")
 public class RunReflectiveCall {
-    
+
+    private static final Map<Object, ReflectiveCallable> CHILD_TO_CALLABLE = new ConcurrentHashMap<>();
     private static final ThreadLocal<ConcurrentMap<Integer, DepthGauge>> methodDepth;
     private static final Function<Integer, DepthGauge> newInstance;
     private static final Logger LOGGER = LoggerFactory.getLogger(RunReflectiveCall.class);
@@ -57,11 +63,9 @@ public static Object intercept(@This final ReflectiveCallable callable, @SuperCa
                     throws Exception {
 
         Object child = null;
-        Object target = null;
 
         try {
             child = getFieldValue(callable, "this$0");
-            target = getFieldValue(callable, "val$target");
         } catch (IllegalAccessException | NoSuchFieldException | SecurityException | IllegalArgumentException e) {
             // handled below
         }
@@ -71,10 +75,8 @@ public static Object intercept(@This final ReflectiveCallable callable, @SuperCa
             runner = Run.getThreadRunner();
         }
 
-        if (ArtifactParams.class.isInstance(target)) {
-            ((ArtifactParams) target).getAtomIdentity().setCallable(callable);
-        }
-        
+        CHILD_TO_CALLABLE.put(Objects.hash(runner, child), callable);
+
         Object result = null;
         Throwable thrown = null;
 
@@ -93,7 +95,18 @@ public static Object intercept(@This final ReflectiveCallable callable, @SuperCa
 
         return result;
     }
-    
+
+    /**
+     * Get the {@link ReflectiveCallable} object for the specified class runner or method description.
+     *
+     * @param runner JUnit class runner
+     * @param child JUnit child object (runner or framework method)
+     * @return <b>ReflectiveCallable</b> object (may be {@code null})
+     */
+    static ReflectiveCallable getCallableOf(Object runner, Object child) {
+        return CHILD_TO_CALLABLE.get(Objects.hash(runner, child));
+    }
+
     /**
      * Fire the {@link MethodWatcher#beforeInvocation(Object, Object, ReflectiveCallable) event.
      * <p>
@@ -128,7 +141,7 @@ private static boolean fireBeforeInvocation(Object runner, Object child, Reflect
     }
 
     /**
-     * Fire the {@link MethodWatcher#afterInvocation(Object, Object, ReflectiveCallable) event.
+     * Fire the {@link MethodWatcher#afterInvocation(Object, Object, ReflectiveCallable, Throwable) event.
      * <p>
      * If the {@code afterInvocation} event for the specified method has already been fired, do nothing.
      *