Merge pull request #38 from Nordstrom/pr/add-watcher-finder

Pr/add watcher finder

Author: sbabcoc

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

@@ -1,6 +1,7 @@
 package com.nordstrom.automation.junit;
 
 import java.util.Map;
+import java.util.Optional;
 import java.util.ServiceLoader;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentHashMap;
@@ -79,4 +80,25 @@ static Object getRunnerForTarget(Object target) {
     static Object getTargetForRunner(Object runner) {
         return RUNNER_TO_TARGET.get(runner);
     }
+    
+    /**
+     * Get reference to an instance of the specified watcher type.
+     * 
+     * @param <T> watcher type
+     * @param watcherType watcher type
+     * @return optional watcher instance
+     */
+    @SuppressWarnings("unchecked")
+    static <T extends JUnitWatcher> Optional<T> getAttachedWatcher(Class<T> watcherType) {
+        if (TestObjectWatcher.class.isAssignableFrom(watcherType)) {
+            synchronized(objectWatcherLoader) {
+                for (TestObjectWatcher watcher : objectWatcherLoader) {
+                    if (watcher.getClass() == watcherType) {
+                        return Optional.of((T) watcher);
+                    }
+                }
+            }
+        }
+        return Optional.empty();
+    }
 }

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

@@ -0,0 +1,8 @@
+package com.nordstrom.automation.junit;
+
+/**
+ * <b>JUnitWatcher</b> is a marker interface for JUnit test execution event watchers.
+ */
+public interface JUnitWatcher {
+    
+}

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

@@ -8,11 +8,13 @@
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.Arrays;
+import java.util.Optional;
 import java.util.ServiceLoader;
 import java.util.concurrent.Callable;
 
 import org.junit.Test;
 import org.junit.runner.Description;
+import org.junit.runner.notification.RunListener;
 import org.junit.runners.model.TestClass;
 import com.nordstrom.automation.junit.JUnitConfig.JUnitSettings;
 import com.nordstrom.common.base.UncheckedThrow;
@@ -349,4 +351,38 @@ static Object callProxy(final Callable<?> proxy) throws Exception {
             throw UncheckedThrow.throwUnchecked(e.getCause());
         }
     }
+    
+    /**
+     * Get reference to an instance of the specified watcher type.
+     * 
+     * @param <T> watcher type
+     * @param watcherType watcher type
+     * @return optional watcher instance
+     */
+    public static <T extends JUnitWatcher> Optional<T> getAttachedWatcher(Class<T> watcherType) {
+        Optional<T> watcher = CreateTest.getAttachedWatcher(watcherType);
+        if (watcher.isPresent()) return watcher;
+        
+        watcher = Run.getAttachedWatcher(watcherType);
+        if (watcher.isPresent()) return watcher;
+        
+        watcher = RunAnnouncer.getAttachedWatcher(watcherType);
+        if (watcher.isPresent()) return watcher;
+        
+        watcher = RunAnnouncer.getAttachedWatcher(watcherType);
+        if (watcher.isPresent()) return watcher;
+        
+        return RunReflectiveCall.getAttachedWatcher(watcherType);
+    }
+    
+    /**
+     * Get reference to an instance of the specified listener type.
+     * 
+     * @param <T> listener type
+     * @param listenerType listener type
+     * @return optional listener instance
+     */
+    public static <T extends RunListener> Optional<T> getAttachedListener(Class<T> listenerType) {
+        return Run.getAttachedListener(listenerType);
+    }
 }

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

@@ -5,7 +5,7 @@
 /**
  * This interface defines the methods implemented by JUnit method watchers.
  */
-public interface MethodWatcher {
+public interface MethodWatcher extends JUnitWatcher {
 
     /**
      * Invoked before each test or configuration method is invoked

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

@@ -4,6 +4,7 @@
 import java.util.Deque;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.ServiceLoader;
 import java.util.Set;
 import java.util.concurrent.Callable;
@@ -160,4 +161,44 @@ static boolean fireRunFinished(Object runner) {
         }
         return false;
     }
+    
+    /**
+     * Get reference to an instance of the specified watcher type.
+     * 
+     * @param <T> watcher type
+     * @param watcherType watcher type
+     * @return optional watcher instance
+     */
+    @SuppressWarnings("unchecked")
+    static <T extends JUnitWatcher> Optional<T> getAttachedWatcher(Class<T> watcherType) {
+        if (RunnerWatcher.class.isAssignableFrom(watcherType)) {
+            synchronized(runnerWatcherLoader) {
+                for (RunnerWatcher watcher : runnerWatcherLoader) {
+                    if (watcher.getClass() == watcherType) {
+                        return Optional.of((T) watcher);
+                    }
+                }
+            }
+        }
+        return Optional.empty();
+    }
+    
+    /**
+     * Get reference to an instance of the specified listener type.
+     * 
+     * @param <T> listener type
+     * @param listenerType listener type
+     * @return optional listener instance
+     */
+    @SuppressWarnings("unchecked")
+    static <T extends RunListener> Optional<T> getAttachedListener(Class<T> listenerType) {
+        synchronized(runListenerLoader) {
+            for (RunListener listener : runListenerLoader) {
+                if (listener.getClass() == listenerType) {
+                    return Optional.of((T) listener);
+                }
+            }
+        }
+        return Optional.empty();
+    }
 }

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

@@ -1,5 +1,6 @@
 package com.nordstrom.automation.junit;
 
+import java.util.Optional;
 import java.util.ServiceLoader;
 import org.junit.internal.AssumptionViolatedException;
 import org.junit.runner.Description;
@@ -94,4 +95,25 @@ static AtomicTest getAtomicTest(Failure failure) {
         atomicTest.setThrowable(failure.getException());
         return atomicTest;
     }
+    
+    /**
+     * Get reference to an instance of the specified watcher type.
+     * 
+     * @param <T> watcher type
+     * @param watcherType watcher type
+     * @return optional watcher instance
+     */
+    @SuppressWarnings("unchecked")
+    static <T extends JUnitWatcher> Optional<T> getAttachedWatcher(Class<T> watcherType) {
+        if (RunWatcher.class.isAssignableFrom(watcherType)) {
+            synchronized(runWatcherLoader) {
+                for (RunWatcher watcher : runWatcherLoader) {
+                    if (watcher.getClass() == watcherType) {
+                        return Optional.of((T) watcher);
+                    }
+                }
+            }
+        }
+        return Optional.empty();
+    }
 }

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

@@ -4,7 +4,6 @@
 
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Objects;
 import java.util.Optional;
 import java.util.ServiceLoader;
 import java.util.concurrent.Callable;
@@ -100,16 +99,18 @@ public static Object intercept(@This final Object callable, @SuperCall final Cal
     /**
      * Get reference to an instance of the specified watcher type.
      * 
+     * @param <T> watcher type
      * @param watcherType watcher type
      * @return optional watcher instance
      */
-    public static Optional<MethodWatcher> getAttachedWatcher(
-                    Class<? extends MethodWatcher> watcherType) {
-        Objects.requireNonNull(watcherType, "[watcherType] must be non-null");
-        synchronized(methodWatcherLoader) {
-            for (MethodWatcher watcher : methodWatcherLoader) {
-                if (watcher.getClass() == watcherType) {
-                    return Optional.of(watcher);
+    @SuppressWarnings("unchecked")
+    static <T extends JUnitWatcher> Optional<T> getAttachedWatcher(Class<T> watcherType) {
+        if (MethodWatcher.class.isAssignableFrom(watcherType)) {
+            synchronized(methodWatcherLoader) {
+                for (MethodWatcher watcher : methodWatcherLoader) {
+                    if (watcher.getClass() == watcherType) {
+                        return Optional.of((T) watcher);
+                    }
                 }
             }
         }

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

@@ -5,7 +5,7 @@
 /**
  * This interface defines the methods implemented by JUnit run watchers.
  */
-public interface RunWatcher {
+public interface RunWatcher extends JUnitWatcher {
 
     /**
      * Called when an atomic test is about to be started.

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

@@ -1,6 +1,6 @@
 package com.nordstrom.automation.junit;
 
-public interface RunnerWatcher {
+public interface RunnerWatcher extends JUnitWatcher {
 
     /**
      * Called when a test runner is about to run.

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

@@ -4,7 +4,7 @@
  * This interface defines the methods implemented by JUnit test object watchers. These watchers are registered via a
  * ServiceLoader provider configuration file.
  */
-public interface TestObjectWatcher {
+public interface TestObjectWatcher extends JUnitWatcher {
 
     /**
      * Invoked when a test class instance gets created.