Merge pull request #5 in MFATT/junit-foundation from pr/revise-default-artifact-path to master

* commit 'fff78e233680aaf5a61c67345bd55173ac5572b3':
  Finish JavaDoc
  Add JavaDoc
  Revise hook install to prevent re-application

Author: Babcock, Scott

pom.xml

@@ -14,7 +14,7 @@
   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <lifecycle-mapping.version>1.0.0</lifecycle-mapping.version>
-    <nordstrom-common.version>1.2.2.0</nordstrom-common.version>
+    <nordstrom-common.version>1.3.0.0</nordstrom-common.version>
     <surefire-plugin.version>2.19.1</surefire-plugin.version>
     <compiler-plugin.version>3.6.0</compiler-plugin.version>
     <source-plugin.version>3.0.1</source-plugin.version>

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

@@ -3,7 +3,6 @@
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -109,8 +108,8 @@ public Optional<Path> captureArtifact(Throwable reason) {
      * @return path of artifact storage directory
      */
     private Path getCollectionPath() {
-        Path collectionPath = Paths.get(System.getProperty("user.dir"));
-        return collectionPath.resolve(provider.getArtifactPath());
+        Path collectionPath = PathUtils.ReportsDirectory.getPathForObject(instance);
+        return collectionPath.resolve(provider.getArtifactPath(instance));
     }
 
     /**

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

@@ -1,10 +1,73 @@
 package com.nordstrom.automation.junit;
 
 import java.nio.file.Path;
-import java.nio.file.Paths;
-
 import org.slf4j.Logger;
 
+import com.nordstrom.common.file.PathUtils;
+
+/**
+ * This interface defines the contract fulfilled by artifact capture providers. Instances of this interface supply the
+ * scenario-specify implementation for artifact capture through the {@link ArtifactCollector} listener.
+ * <br><br>
+ * <b>IMPLEMENTING ARTIFACTTYPE</b>
+ * <pre><code>
+ * package com.nordstrom.example;
+ * 
+ * import java.nio.file.Path;
+ * 
+ * import org.slf4j.Logger;
+ * import org.slf4j.LoggerFactory;
+ * import org.testng.ITestResult;
+ * 
+ * import com.nordstrom.automation.junit.ArtifactType;
+ * 
+ * public class MyArtifactType implements ArtifactType {
+ *     
+ *     private static final String ARTIFACT_PATH = "artifacts";
+ *     private static final String EXTENSION = "txt";
+ *     private static final String ARTIFACT = "This text artifact was captured for '%s'";
+ *     private static final Logger LOGGER = LoggerFactory.getLogger(MyArtifactType.class);
+ * 
+ *     &#64;Override
+ *     public boolean canGetArtifact(Object instance) {
+ *         return true;
+ *     }
+ * 
+ *     &#64;Override
+ *     public byte[] getArtifact(Object instance, Throwable reason) {
+ *         return String.format(ARTIFACT, instance.getSimpleName()).getBytes().clone();
+ *     }
+ *     
+ *     &#64;Override
+ *     public Page getArtifactPath(Object instance) {
+ *         return ArtifactType.super.getArtifactPath(instance).resolve(ARTIFACT_PATH);
+ *     }
+ * 
+ *     &#64;Override
+ *     public String getArtifactExtension() {
+ *         return EXTENSION;
+ *     }
+ *     
+ *     &#64;Override
+ *     public Logger getLogger() {
+ *         return LOGGER;
+ *     }
+ * }
+ * </code></pre>
+ * <b>CREATING A TYPE-SPECIFIC ARTIFACT COLLECTOR</b>
+ * <pre><code>
+ * package com.nordstrom.example;
+ * 
+ * import com.nordstrom.automation.testng.ArtifactCollector;
+ * 
+ * public class MyArtifactCapture extends ArtifactCollector<MyArtifactType> {
+ *     
+ *     public MyArtifactCapture() {
+ *         super(new MyArtifactType());
+ *     }
+ * }
+ * </code></pre>
+ */
 public interface ArtifactType {
 
     /**
@@ -34,12 +97,14 @@ public interface ArtifactType {
     /**
      * Get the path at which to store artifacts.
      * 
+     * @param instance JUnit test class instance
      * @return artifact storage path
      */
-    default Path getArtifactPath() {
-        return Paths.get("");
+    default Path getArtifactPath(Object instance) {
+        return PathUtils.ReportsDirectory.getPathForObject(instance);
     }
 
+    
     /**
      * Get the extension for artifact files of this type.
      * <br><br>

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

@@ -17,7 +17,7 @@ public class HookInstallingPlugin implements Plugin {
 
     @Override
     public boolean matches(TypeDescription target) {
-        return true;
+        return ! target.isAssignableTo(Hooked.class);
     }
 
     @Override

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

@@ -2,13 +2,17 @@
 
 import static net.bytebuddy.matcher.ElementMatchers.*;
 
+import java.util.HashMap;
+import java.util.Map;
+
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runners.BlockJUnit4ClassRunner;
 import org.junit.runners.model.InitializationError;
 
 import com.nordstrom.common.base.UncheckedThrow;
+import com.nordstrom.common.file.PathUtils.ReportsDirectory;
 
 import net.bytebuddy.ByteBuddy;
 import net.bytebuddy.implementation.MethodDelegation;
@@ -21,6 +25,8 @@
  */
 public final class HookInstallingRunner extends BlockJUnit4ClassRunner {
 
+    private static Map<Class<?>, Class<?>> proxyMap = new HashMap<>();
+    
     public HookInstallingRunner(Class<?> klass) throws InitializationError {
         super(klass);
     }
@@ -39,28 +45,36 @@ public Object createTest() throws Exception {
      * @param testObj test class object to be enhanced
      * @return enhanced test class object
      */
-    private Object installHooks(Object testObj) {
+    private synchronized Object installHooks(Object testObj) {
         Class<?> testClass = testObj.getClass();
         MethodInterceptor.attachWatchers(testClass);
 
         if (testObj instanceof Hooked) {
             return testObj;
         }
 
-        try {
-            
-            Class<?> proxyType = new ByteBuddy()
-                    .subclass(testClass)
-                    .method(isAnnotatedWith(anyOf(Test.class, Before.class, After.class)))
-                    .intercept(MethodDelegation.to(MethodInterceptor.class))
-                    .implement(Hooked.class)
-                    .make()
-                    .load(testClass.getClassLoader())
-                    .getLoaded();
+        Class<?> proxyType = proxyMap.get(testClass);
+        
+        if (proxyType == null) {
+            try {
+                proxyType = new ByteBuddy()
+                        .subclass(testClass)
+                        .name(getSubclassName(testObj))
+                        .method(isAnnotatedWith(anyOf(Test.class, Before.class, After.class)))
+                        .intercept(MethodDelegation.to(MethodInterceptor.class))
+                        .implement(Hooked.class)
+                        .make()
+                        .load(testClass.getClassLoader())
+                        .getLoaded();
+                proxyMap.put(testClass, proxyType);
+            } catch (SecurityException | IllegalArgumentException e) {
+                throw UncheckedThrow.throwUnchecked(e);
+            }
+        }
 
+        try {
             return proxyType.newInstance();
-            
-        } catch (SecurityException | IllegalAccessException | IllegalArgumentException | InstantiationException e) {
+        } catch (InstantiationException | IllegalAccessException e) {
             throw UncheckedThrow.throwUnchecked(e);
         }
     }
@@ -75,4 +89,30 @@ public static Class<?> getInstanceClass(Object instance) {
         Class<?> clazz = instance.getClass();      
         return (instance instanceof Hooked) ? clazz.getSuperclass() : clazz;
     }
+    
+    /**
+     * Get fully-qualified name to use for hooked test class.
+     * 
+     * @param testObj test class object being hooked
+     * @return fully-qualified name for hooked subclass
+     */
+    private static String getSubclassName(Object testObj) {
+        Class<?> testClass = testObj.getClass();
+        String testClassName = testClass.getSimpleName();
+        String testPackageName = testClass.getPackage().getName();
+        ReportsDirectory constant = ReportsDirectory.fromObject(testObj);
+        
+        switch (constant) {
+            case FAILSAFE_2:
+            case FAILSAFE_3:
+            case SUREFIRE_2:
+            case SUREFIRE_3:
+            case SUREFIRE_4:
+                return testPackageName + ".Hooked" + testClassName;
+                
+            default:
+                return testClass.getCanonicalName() + "Hooked";
+        }
+        
+    }
 }