Add support for Google TestParameterInjector (#137)

sbabcoc · web-flow · commit 441eb4d6e6d4 · 2025-03-27T18:33:32.000-07:00
diff --git a/README.md b/README.md
@@ -12,6 +12,7 @@
 * [Parameterized](https://github.com/junit-team/junit4/blob/main/src/main/java/org/junit/runners/Parameterized.java)
 * [Theories](https://github.com/junit-team/junit4/blob/main/src/main/java/org/junit/experimental/theories/Theories.java)
 * [JUnitParamsRunner](https://github.com/Pragmatists/JUnitParams/blob/master/src/main/java/junitparams/JUnitParamsRunner.java)
+* [TestParameterInjector](https://github.com/google/TestParameterInjector/blob/main/junit4/src/main/java/com/google/testing/junit/testparameterinjector/TestParameterInjector.java)
 * [PowerMockRunner](https://github.com/powermock/powermock/blob/release/2.x/powermock-modules/powermock-module-junit4/src/main/java/org/powermock/modules/junit4/PowerMockRunner.java) (requires delegation)
 
 The native implementation of **PowerMockRunner** uses a deprecated JUnit runner model that **JUnit Foundation** doesn't support. You need to delegate test execution to the standard **BlockJUnit4ClassRunner** (or subclasses thereof) to enable reporting of test lifecycle events. This is specified via the [@PowerMockRunnerDelegate](https://github.com/powermock/powermock/blob/release/2.x/powermock-modules/powermock-module-junit4/src/main/java/org/powermock/modules/junit4/PowerMockRunnerDelegate.java) annotation, as shown below:
diff --git a/pom.xml b/pom.xml
@@ -36,6 +36,7 @@
     <logback.version>1.2.11</logback.version>
     <junitparams.version>1.1.1</junitparams.version>
     <powermock.version>2.0.9</powermock.version>
+    <paraminjector.version>1.18</paraminjector.version>
     <compiler-plugin.version>3.10.1</compiler-plugin.version>
     <surefire-plugin.version>3.0.0-M7</surefire-plugin.version>
     <source-plugin.version>3.2.1</source-plugin.version>
@@ -117,6 +118,11 @@
         <artifactId>powermock-api-mockito2</artifactId>
         <version>${powermock.version}</version>
       </dependency>
+      <dependency>
+        <groupId>com.google.testparameterinjector</groupId>
+        <artifactId>test-parameter-injector</artifactId>
+        <version>${paraminjector.version}</version>
+      </dependency>
     </dependencies>
   </dependencyManagement>
   
@@ -167,6 +173,11 @@
       <artifactId>powermock-api-mockito2</artifactId>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>com.google.testparameterinjector</groupId>
+      <artifactId>test-parameter-injector</artifactId>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
 
   <build>
@@ -219,6 +230,11 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
+        <configuration>
+          <compilerArgs>
+            <arg>-parameters</arg>
+          </compilerArgs>
+        </configuration>
       </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
diff --git a/src/main/java/com/nordstrom/automation/junit/ArtifactCollector.java b/src/main/java/com/nordstrom/automation/junit/ArtifactCollector.java
@@ -141,12 +141,21 @@ private String getArtifactBaseName() {
         int hashcode = getParameters().hashCode();
         if (hashcode != 0) {
             String hashStr = String.format("%08X", hashcode);
-            return getDescription().getMethodName() + "-" + hashStr;
+            return getSanitizedName() + "-" + hashStr;
         } else {
-            return getDescription().getMethodName();
+            return getSanitizedName();
         }
     }
     
+    /**
+     * Get the target method name, replacing Windows file name reserved characters with '_'.
+     * 
+     * @return sanitized target method name
+     */
+    private String getSanitizedName() {
+        return getDescription().getMethodName().replaceAll("[\\/:*?\"<>|]", "_");
+    }
+    
     /**
      * Record the path at which the specified artifact was store in the indicated test result.
      * 
diff --git a/src/main/java/com/nordstrom/automation/junit/AtomicTest.java b/src/main/java/com/nordstrom/automation/junit/AtomicTest.java
@@ -30,7 +30,7 @@
 public class AtomicTest {
     private final Object runner;
     private final Description description;
-    private final FrameworkMethod identity;
+    private FrameworkMethod identity;
     private final List<FrameworkMethod> particles;
     private Throwable thrown;
     
@@ -61,6 +61,14 @@ public Object getRunner() {
     public Description getDescription() {
         return description;
     }
+    
+    /**
+     * Set the "identity" method for this atomic test - the core {@link Test &#64;Test} method.
+     */
+    void setIdentity(FrameworkMethod method) {
+        identity = method;
+        particles.set(0, method);
+    }
 
     /**
      * Get the "identity" method for this atomic test - the core {@link Test &#64;Test} method.
diff --git a/src/main/java/com/nordstrom/automation/junit/CreateTest.java b/src/main/java/com/nordstrom/automation/junit/CreateTest.java
@@ -67,6 +67,22 @@ public static Object intercept(@This final Object runner, @Argument(0) final Fra
         
         if (0 == depthGauge.decreaseDepth()) {
             METHOD_DEPTH.get().remove(hashCode);
+            createMappingsFor(runner, method, target);
+        }
+        
+        return target;
+    }
+
+    /**
+     * Create mappings for the specified test runner/test method/test class instance.
+     * 
+     * @param runner underlying test runner
+     * @param method target test method
+     * @param target test class instance
+     */
+    static void createMappingsFor(final Object runner, final FrameworkMethod method, final Object target) {
+        // if mappings haven't been created
+        if (getMethodFor(target) == null) {
             LOGGER.debug("testObjectCreated: {}", target);
             TARGET_TO_METHOD.put(toMapKey(target), method);
             TARGET_TO_RUNNER.put(toMapKey(target), runner);
@@ -77,15 +93,13 @@ public static Object intercept(@This final Object runner, @Argument(0) final Fra
             // if notifier hasn't been initialized yet
             if ( ! EachTestNotifierInit.setTestTarget(runner, method, target)) {
                 // store target for subsequent retrieval
-                HASHCODE_TO_TARGET.put(hashCode, target);
+                HASHCODE_TO_TARGET.put(Objects.hash(runner, method.toString()), target);
             }
             
             for (TestObjectWatcher watcher : LifecycleHooks.getObjectWatchers()) {
                 watcher.testObjectCreated(runner, method, target);
             }
         }
-        
-        return target;
     }
     
     /**
diff --git a/src/main/java/com/nordstrom/automation/junit/EachTestNotifierInit.java b/src/main/java/com/nordstrom/automation/junit/EachTestNotifierInit.java
@@ -98,11 +98,16 @@ public static void interceptor(@Argument(0) final RunNotifier notifier,
      * @param description description of the test that is about to be run
      * @return {@link AtomicTest} object
      */
-    private static AtomicTest newAtomicTestFor(Description description) {
-        // create new atomic test object
-        AtomicTest atomicTest = new AtomicTest(description);
-        // create description => atomic test mapping
-        DESCRIPTION_TO_ATOMICTEST.put(description.hashCode(), atomicTest);
+    static AtomicTest newAtomicTestFor(Description description) {
+        // get atomic test for this description
+        AtomicTest atomicTest = getAtomicTestOf(description);
+        // if none was found
+        if (atomicTest == null) {
+            // create new atomic test object
+            atomicTest = new AtomicTest(description);
+            // create description => atomic test mapping
+            DESCRIPTION_TO_ATOMICTEST.put(description.hashCode(), atomicTest);
+        }
         
         return atomicTest;
     }
diff --git a/src/main/java/com/nordstrom/automation/junit/LifecycleHooks.java b/src/main/java/com/nordstrom/automation/junit/LifecycleHooks.java
@@ -12,7 +12,7 @@
 import java.util.concurrent.ConcurrentMap;
 import java.util.function.Function;
 
-import org.apache.commons.lang3.reflect.MethodUtils;
+import org.apache.commons.lang3.ArrayUtils;
 import org.junit.internal.runners.model.ReflectiveCallable;
 import org.junit.runner.Description;
 import org.junit.runner.notification.RunListener;
@@ -337,12 +337,66 @@ static String getSubclassName(Object testObj) {
     @SuppressWarnings("unchecked")
     static <T> T invoke(Object target, String methodName, Object... parameters) {
         try {
-            return (T) MethodUtils.invokeMethod(target, true, methodName, parameters);
+            Method method = findMethod(target, methodName, parameters);
+            return (T) method.invoke(target, parameters);
         } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
             throw UncheckedThrow.throwUnchecked(e);
         }
     }
     
+    /**
+     * Find the named method compatible with the supplied argument in the target object.
+     * 
+     * @param target target object
+     * @param methodName name of the desired method
+     * @param parameters parameters for the method invocation
+     * @return {@link Method} object for invocation
+     * @throws NoSuchMethodException
+     */
+    private static Method findMethod(Object target, String methodName, Object... parameters)
+            throws NoSuchMethodException {
+        Class<?> clazz = target.getClass();
+        Class<?>[] paramTypes = new Class<?>[parameters.length];
+
+        for (int i = 0; i < parameters.length; i++) {
+            paramTypes[i] = parameters[i].getClass();
+        }
+
+        while (clazz != null) {
+            for (Method method : clazz.getDeclaredMethods()) {
+                if (method.getName().equals(methodName) &&
+                        isCompatible(method.getParameterTypes(), paramTypes)) {
+                    method.setAccessible(true);
+                    return method;
+                }
+            }
+            clazz = clazz.getSuperclass(); // Move up the class hierarchy
+        }
+
+        throw new NoSuchMethodException("Failed finding method " + 
+                methodName + " " + ArrayUtils.toString(paramTypes) +
+                " in target " + target.getClass().getName());
+    }
+
+    /**
+     * Determine if declared method parameter types are compatible with provided parameters.
+     *  
+     * @param declaredParams types of parameters declared by discovered method
+     * @param providedParams types of provided parameters
+     * @return {@code true} if declared parameters are compatible; otherwise {@code false}
+     */
+    private static boolean isCompatible(Class<?>[] declaredParams, Class<?>[] providedParams) {
+        if (declaredParams.length != providedParams.length) {
+            return false;
+        }
+        for (int i = 0; i < declaredParams.length; i++) {
+            if (!declaredParams[i].isAssignableFrom(providedParams[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    
     /**
      * Get the specified field of the supplied object.
      * 
diff --git a/src/main/java/com/nordstrom/automation/junit/RetryHandler.java b/src/main/java/com/nordstrom/automation/junit/RetryHandler.java
@@ -60,6 +60,9 @@ public static Throwable runChildWithRetry(final Object runner, final FrameworkMe
             EachTestNotifier eachNotifier = new EachTestNotifier(notifier, description);
             AtomicTest atomicTest = EachTestNotifierInit.getAtomicTestOf(description);
             
+            // preserve original method
+            atomicTest.setIdentity(method);
+            
             // if atomic test is theory
             if (atomicTest.isTheory()) {
                 // retrieve cached method block statement
@@ -145,7 +148,8 @@ static int getMaxRetry(Object runner, final FrameworkMethod method) {
         NoRetry noRetryOnClass = method.getDeclaringClass().getAnnotation(NoRetry.class);
         
         // if method isn't ignored or excluded from retry attempts
-        if (Boolean.FALSE.equals(invoke(runner, "isIgnored", method)) && (noRetryOnMethod == null) && (noRetryOnClass == null)) {
+        if (Boolean.FALSE.equals(invoke(runner, "isIgnored", method)) &&
+                (noRetryOnMethod == null) && (noRetryOnClass == null)) {
             // get configured maximum retry count
             maxRetry = getConfig().getInteger(JUnitSettings.MAX_RETRY.key(), Integer.valueOf(0));
         }
diff --git a/src/main/java/com/nordstrom/automation/junit/RunReflectiveCall.java b/src/main/java/com/nordstrom/automation/junit/RunReflectiveCall.java
@@ -171,16 +171,29 @@ private static boolean fireBeforeInvocation(Object runner, Object child, Reflect
             DepthGauge depthGauge = LifecycleHooks.computeIfAbsent(METHOD_DEPTH.get(), callable.hashCode(), NEW_INSTANCE);
             if (0 == depthGauge.increaseDepth()) {
                 if (child instanceof FrameworkMethod) {
-                    Description description = LifecycleHooks.describeChild(runner, child);
+                    FrameworkMethod method = (FrameworkMethod) child;
+                    Description description = LifecycleHooks.describeChild(runner, method);
                     if (LOGGER.isDebugEnabled()) {
                         try {
-                            LOGGER.debug("beforeInvocation: {}", (description != null) ? description : child);
+                            LOGGER.debug("beforeInvocation: {}", (description != null) ? description : method);
                         } catch (Throwable t) {
                             // nothing to do here
                         }
                     }
                     if ((description != null) && AtomicTest.isTest(description)) {
                         DESCRIPTION_TO_CALLABLE.put(description.hashCode(), callable);
+                        
+                        // get target for description
+                        Object target = getTargetFor(description);
+                        // if target acquired
+                        if (target != null) {
+                            // ensure that test object creation is tracked
+                            CreateTest.createMappingsFor(runner, method, target);
+                            // ensure that description has matching atomic test
+                            EachTestNotifierInit.newAtomicTestFor(description);
+                            // ensure that description <=> target mappings are set
+                            EachTestNotifierInit.setTestTarget(runner, method, target);
+                        }
                     }
                 }
                 for (MethodWatcher watcher : LifecycleHooks.getMethodWatchers()) {
diff --git a/src/test/java/com/nordstrom/automation/junit/ArtifactCollectorParamInjector.java b/src/test/java/com/nordstrom/automation/junit/ArtifactCollectorParamInjector.java
@@ -0,0 +1,56 @@
+package com.nordstrom.automation.junit;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.model.FrameworkMethod;
+
+import com.google.testing.junit.testparameterinjector.TestParameterInjector;
+import com.google.testing.junit.testparameterinjector.TestParameters;
+
+@RunWith(TestParameterInjector.class)
+public class ArtifactCollectorParamInjector extends TestBase {
+    
+    @Override
+    public Optional<Map<String, Object>> getParameters() {
+        AtomicTest atomicTest = LifecycleHooks.getAtomicTestOf(this);
+        FrameworkMethod method = atomicTest.getIdentity();
+        
+        // get test method parameters
+        Class<?>[] paramTypes = method.getMethod().getParameterTypes();
+        
+        try {
+            Object testInfo = LifecycleHooks.getFieldValue(method, "testInfo");
+            List<Object> params = LifecycleHooks.getFieldValue(testInfo, "parameters");
+            
+            // allocate named parameters array
+            Param[] namedParams = new Param[params.size()];
+            // populate named parameters array
+            for (int i = 0; i < params.size(); i++) {
+                Object param = params.get(i);
+                Map<String, Object> paramValue = LifecycleHooks.getFieldValue(param, "value");
+                Entry<String, Object> paramEntry = paramValue.entrySet().iterator().next();
+                namedParams[i] = Param.param(paramEntry.getKey(), paramTypes[i].cast(paramEntry.getValue()));
+            }
+
+            // return params map as Optional
+            return Param.mapOf(namedParams);
+        } catch (IllegalAccessException | NoSuchFieldException | SecurityException e) {
+            return Optional.empty();
+        }
+    }
+    
+    @Test
+    @TestParameters("{input: 'first test'}")
+    @TestParameters("{input: 'second test'}")
+    public void parameterized(String input) {
+        System.out.println("parameterized: input = [" + input + "]");
+        assertEquals("first test", input);
+    }
+}
diff --git a/src/test/java/com/nordstrom/automation/junit/ArtifactCollectorTest.java b/src/test/java/com/nordstrom/automation/junit/ArtifactCollectorTest.java
@@ -308,6 +308,43 @@ public void verifyTheoriesCapture() {
                 "Incorrect event notifications");
         ReferenceReleaseTest.checkLeakReports(checker);
     }
+
+    @Test
+    public void verifyParamInjectorCapture() {
+        RunListenerAdapter rla = new RunListenerAdapter();
+        ReferenceChecker checker = new ReferenceChecker();
+
+        JUnitCore runner = new JUnitCore();
+        runner.addListener(rla);
+        runner.addListener(checker);
+        Result result = runner.run(ArtifactCollectorParamInjector.class);
+        assertFalse(result.wasSuccessful());
+
+        assertEquals(rla.getPassedTests().size(), 1, "Incorrect passed test count");
+        assertEquals(rla.getFailedTests().size(), 1, "Incorrect failed test count");
+        assertEquals(rla.getIgnoredTests().size(), 0, "Incorrect ignored test count");
+        assertEquals(rla.getRetriedTests().size(), 1, "Incorrect retried test count");
+
+        Description description = rla.getFailedTests().get(0);
+        UnitTestCapture watcher = rla.getWatcher(description);
+        assertNotNull(watcher, "Unit test artifact collector not registered");
+        assertEquals(watcher.getArtifactProvider().getCaptureState(), CaptureState.CAPTURE_SUCCESS, "Incorrect artifact provider capture state");
+        assertTrue(watcher.getArtifactPath().isPresent(), "Artifact capture output path is not present");
+        
+        Optional<UnitTestWatcher> optWatcher = LifecycleHooks.getAttachedWatcher(UnitTestWatcher.class);
+        assertTrue(optWatcher.isPresent(), "Unit test watcher not attached");
+        UnitTestWatcher testWatcher = (UnitTestWatcher) optWatcher.get();
+        List<Notification> notifications = testWatcher.getNotificationsFor(rla.getPassedTests().get(0));
+        assertEquals(notifications, Arrays.asList(
+                Notification.STARTED, Notification.FINISHED),
+                "Incorrect event notifications");
+        notifications = testWatcher.getNotificationsFor(description);
+        assertEquals(notifications, Arrays.asList(
+                Notification.STARTED, Notification.RETRIED, Notification.FINISHED,
+                Notification.STARTED, Notification.FAILED, Notification.FINISHED),
+                "Incorrect event notifications");
+        ReferenceReleaseTest.checkLeakReports(checker);
+    }
     
     @AfterClass
     public static void afterClass() {
diff --git a/src/test/java/com/nordstrom/automation/junit/ReferenceReleaseParamInjector.java b/src/test/java/com/nordstrom/automation/junit/ReferenceReleaseParamInjector.java
diff --git a/src/test/java/com/nordstrom/automation/junit/ReferenceReleaseTest.java b/src/test/java/com/nordstrom/automation/junit/ReferenceReleaseTest.java
