Get real invoked method description; enhance ArtifactParams feature (#66)

Author: sbabcoc

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

@@ -9,6 +9,13 @@
  */
 public interface ArtifactParams extends Params {
 
+    /**
+     * Get the {@link AtomIdentity} test watcher for the current test class instance.
+     * 
+     * @return {@code AtomIdentity} test watcher
+     */
+    AtomIdentity getAtomIdentity();
+    
     /**
      * Get the JUnit method description object for the current test class instance.
      * 

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

@@ -2,6 +2,7 @@
 
 import java.util.Map;
 
+import org.junit.internal.runners.model.ReflectiveCallable;
 import org.junit.rules.TestWatcher;
 import org.junit.runner.Description;
 
@@ -17,6 +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;
@@ -39,6 +41,32 @@ 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}
+     */
+    @Override
+    public AtomIdentity getAtomIdentity() {
+        return this;
+    }
+    
     /**
      * {@inheritDoc}
      */
@@ -57,5 +85,5 @@ public Optional<Map<String, Object>> getParameters() {
         }
         return Optional.absent();
     }
-    
+
 }

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

@@ -33,6 +33,13 @@ public AtomicTest(Object runner, T identity) {
         this.description = invoke(runner, "describeChild", identity);
         this.particles = invoke(runner, "getChildren");
     }
+    
+    public AtomicTest(AtomicTest<T> original, Description description) {
+        this.runner = original.runner;
+        this.identity = original.identity;
+        this.description = description;
+        this.particles = original.particles;
+    }
 
     /**
      * Get the runner for this atomic test.

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

@@ -19,18 +19,8 @@ public class CreateTest {
 
     private static final Map<Object, Object> TARGET_TO_RUNNER = new ConcurrentHashMap<>();
     private static final Map<Object, Object> RUNNER_TO_TARGET = new ConcurrentHashMap<>();
-    private static final ThreadLocal<DepthGauge> DEPTH;
     private static final Logger LOGGER = LoggerFactory.getLogger(CreateTest.class);
 
-    static {
-        DEPTH = new ThreadLocal<DepthGauge>() {
-            @Override
-            protected DepthGauge initialValue() {
-                return new DepthGauge();
-            }
-        };
-    }
-    
     /**
      * Interceptor for the {@link org.junit.runners.BlockJUnit4ClassRunner#createTest createTest} method.
      * 
@@ -43,26 +33,19 @@ protected DepthGauge initialValue() {
     public static Object intercept(@This final Object runner,
                     @SuperCall final Callable<?> proxy) throws Exception {
 
-        Object target;
-        try {
-            DEPTH.get().increaseDepth();
-            target = LifecycleHooks.callProxy(proxy);
-        } finally {
-            DEPTH.get().decreaseDepth();
-        }
-        
-        TARGET_TO_RUNNER.put(target, runner);
-        RUNNER_TO_TARGET.put(runner, target);
+        Object target = LifecycleHooks.callProxy(proxy);
+        // apply parameter-based global timeout
+        TimeoutUtils.applyTestTimeout(runner, target);
 
-        if (DEPTH.get().atGroundLevel()) {
+        if (null == TARGET_TO_RUNNER.put(target, runner)) {
             LOGGER.debug("testObjectCreated: {}", target);
+            RUNNER_TO_TARGET.put(runner, target);
+            
             for (TestObjectWatcher watcher : LifecycleHooks.getObjectWatchers()) {
                 watcher.testObjectCreated(target, runner);
             }
         }
 
-        // apply parameter-based global timeout
-        TimeoutUtils.applyTestTimeout(runner, target);
         return target;
     }
 

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

@@ -31,7 +31,7 @@ public class RunAnnouncer extends RunListener {
     @SuppressWarnings({"rawtypes", "unchecked"})
     public void testStarted(Description description) throws Exception {
         LOGGER.debug("testStarted: {}", description);
-        AtomicTest<?> atomicTest = getAtomicTestOf(description);
+        AtomicTest<?> atomicTest = newAtomicTest(description);
         for (RunWatcher watcher : LifecycleHooks.getRunWatchers()) {
             if (isSupported(watcher, atomicTest)) {
                 watcher.testStarted(atomicTest);
@@ -110,7 +110,25 @@ public void testIgnored(Description description) throws Exception {
     static <T> AtomicTest<T> newAtomicTest(Object runner, T identity) {
         AtomicTest<T> atomicTest = new AtomicTest<>(runner, identity);
         RUNNER_TO_ATOMICTEST.put(runner, atomicTest);
-        RUNNER_TO_ATOMICTEST.put(atomicTest.getDescription(), atomicTest);
+        return atomicTest;
+    }
+    
+    /**
+     * Create new atomic test object for the specified description.
+     * 
+     * @param <T> type of children associated with the specified runner
+     * @param description description of the test that is about to be run
+     * @return {@link AtomicTest} object (may be {@code null})
+     */
+    static <T> AtomicTest<T> newAtomicTest(Description description) {
+        AtomicTest<T> atomicTest = null;
+        AtomicTest<T> original = getAtomicTestOf(LifecycleHooks.getThreadRunner());
+        
+        if (original != null) {
+            atomicTest = new AtomicTest<>(original, description);
+            RUNNER_TO_ATOMICTEST.put(description, atomicTest);
+        }
+        
         return atomicTest;
     }
 

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

@@ -57,9 +57,11 @@ 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
         }
@@ -68,6 +70,10 @@ public static Object intercept(@This final ReflectiveCallable callable, @SuperCa
         if (runner == null) {
             runner = Run.getThreadRunner();
         }
+
+        if (ArtifactParams.class.isInstance(target)) {
+            ((ArtifactParams) target).getAtomIdentity().setCallable(callable);
+        }
 
         Object result = null;
         Throwable thrown = null;

src/test/java/com/nordstrom/automation/junit/TestBase.java

@@ -12,6 +12,11 @@ public abstract class TestBase implements ArtifactParams {
     @Rule
     public final UnitTestCapture watcher = new UnitTestCapture(this);
 
+    @Override
+    public AtomIdentity getAtomIdentity() {
+        return watcher;
+    }
+    
     @Override
     public Description getDescription() {
         return watcher.getDescription();