Add parameter support for @Captor with JUnit Jupiter (#3133)

Fixes #1382 Co-authored-by: yevhen lazhyntsev <yevhen.lazhyntsev@hulu.com>
mockito · Oct 6, 2023 · 6f4eb02 · 6f4eb02
1 parent fb48e09
commit 6f4eb02
Show file tree

Hide file tree

Showing 8 changed files with 212 additions and 23 deletions.
diff --git a/src/main/java/org/mockito/Captor.java b/src/main/java/org/mockito/Captor.java
@@ -46,6 +46,6 @@
  * @since 1.8.3
  */
 @Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
+@Target({ElementType.FIELD, ElementType.PARAMETER})
 @Documented
 public @interface Captor {}
diff --git a/src/main/java/org/mockito/internal/configuration/CaptorAnnotationProcessor.java b/src/main/java/org/mockito/internal/configuration/CaptorAnnotationProcessor.java
@@ -5,6 +5,7 @@
 package org.mockito.internal.configuration;
 
 import java.lang.reflect.Field;
+import java.lang.reflect.Parameter;
 
 import org.mockito.ArgumentCaptor;
 import org.mockito.Captor;
@@ -29,4 +30,18 @@ public Object process(Captor annotation, Field field) {
         Class<?> cls = new GenericMaster().getGenericType(field);
         return ArgumentCaptor.forClass(cls);
     }
+
+    public static Object process(Parameter parameter) {
+        Class<?> type = parameter.getType();
+        if (!ArgumentCaptor.class.isAssignableFrom(type)) {
+            throw new MockitoException(
+                    "@Captor field must be of the type ArgumentCaptor.\n"
+                            + "Field: '"
+                            + parameter.getName()
+                            + "' has wrong type\n"
+                            + "For info how to use @Captor annotations see examples in javadoc for MockitoAnnotations class.");
+        }
+        Class<?> cls = new GenericMaster().getGenericType(parameter);
+        return ArgumentCaptor.forClass(cls);
+    }
 }
diff --git a/src/main/java/org/mockito/internal/util/reflection/GenericMaster.java b/src/main/java/org/mockito/internal/util/reflection/GenericMaster.java
@@ -5,6 +5,7 @@
 package org.mockito.internal.util.reflection;
 
 import java.lang.reflect.Field;
+import java.lang.reflect.Parameter;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 
@@ -17,6 +18,19 @@ public class GenericMaster {
      */
     public Class<?> getGenericType(Field field) {
         Type generic = field.getGenericType();
+        return getaClass(generic);
+    }
+
+    /**
+     * Resolves the type (parametrized type) of the parameter. If the field is not generic it returns Object.class.
+     *
+     * @param parameter the parameter to inspect
+     */
+    public Class<?> getGenericType(Parameter parameter) {
+        return getaClass(parameter.getType());
+    }
+
+    private Class<?> getaClass(Type generic) {
         if (generic instanceof ParameterizedType) {
             Type actual = ((ParameterizedType) generic).getActualTypeArguments()[0];
             if (actual instanceof Class) {

diff --git a/subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java b/subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java
@@ -7,7 +7,6 @@
 import static org.junit.jupiter.api.extension.ExtensionContext.Namespace.create;
 import static org.junit.platform.commons.support.AnnotationSupport.findAnnotation;
 
-import java.lang.reflect.Parameter;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Optional;
@@ -20,14 +19,15 @@
 import org.junit.jupiter.api.extension.ParameterContext;
 import org.junit.jupiter.api.extension.ParameterResolutionException;
 import org.junit.jupiter.api.extension.ParameterResolver;
-import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.MockitoSession;
 import org.mockito.ScopedMock;
-import org.mockito.internal.configuration.MockAnnotationProcessor;
 import org.mockito.internal.configuration.plugins.Plugins;
 import org.mockito.internal.session.MockitoSessionLoggerAdapter;
 import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.resolver.CaptorParameterResolver;
+import org.mockito.junit.jupiter.resolver.CompositeParameterResolver;
+import org.mockito.junit.jupiter.resolver.MockParameterResolver;
 import org.mockito.quality.Strictness;
 
 /**
@@ -123,6 +123,8 @@ public class MockitoExtension implements BeforeEachCallback, AfterEachCallback,
 
     private final Strictness strictness;
 
+    private final ParameterResolver parameterResolver;
+
     // This constructor is invoked by JUnit Jupiter via reflection or ServiceLoader
     @SuppressWarnings("unused")
     public MockitoExtension() {
@@ -131,6 +133,10 @@ public MockitoExtension() {
 
     private MockitoExtension(Strictness strictness) {
         this.strictness = strictness;
+        this.parameterResolver = new CompositeParameterResolver(
+            new MockParameterResolver(),
+            new CaptorParameterResolver()
+        );
     }
 
     /**
@@ -163,12 +169,12 @@ private Optional<MockitoSettings> retrieveAnnotationFromTestClasses(final Extens
         do {
             annotation = findAnnotation(currentContext.getElement(), MockitoSettings.class);
 
-            if (!currentContext.getParent().isPresent()) {
+            if (currentContext.getParent().isEmpty()) {
                 break;
             }
 
             currentContext = currentContext.getParent().get();
-        } while (!annotation.isPresent() && currentContext != context.getRoot());
+        } while (annotation.isEmpty() && currentContext != context.getRoot());
 
         return annotation;
     }
@@ -188,21 +194,16 @@ public void afterEach(ExtensionContext context) {
 
     @Override
     public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext context) throws ParameterResolutionException {
-        return parameterContext.isAnnotated(Mock.class);
+        return parameterResolver.supportsParameter(parameterContext, context);
     }
 
     @Override
     @SuppressWarnings("unchecked")
     public Object resolveParameter(ParameterContext parameterContext, ExtensionContext context) throws ParameterResolutionException {
-        final Parameter parameter = parameterContext.getParameter();
-        Object mock = MockAnnotationProcessor.processAnnotationForMock(
-            parameterContext.findAnnotation(Mock.class).get(),
-            parameter.getType(),
-            parameter::getParameterizedType,
-            parameter.getName());
-        if (mock instanceof ScopedMock) {
-            context.getStore(MOCKITO).get(MOCKS, Set.class).add(mock);
+        Object resolvedParameter = parameterResolver.resolveParameter(parameterContext, context);
+        if (resolvedParameter instanceof ScopedMock) {
+            context.getStore(MOCKITO).get(MOCKS, Set.class).add(resolvedParameter);
         }
-        return mock;
+        return resolvedParameter;
     }
 }
diff --git a/...nit-jupiter/src/main/java/org/mockito/junit/jupiter/resolver/CaptorParameterResolver.java b/...nit-jupiter/src/main/java/org/mockito/junit/jupiter/resolver/CaptorParameterResolver.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.junit.jupiter.resolver;
+
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
+import org.mockito.Captor;
+import org.mockito.internal.configuration.CaptorAnnotationProcessor;
+
+public class CaptorParameterResolver implements ParameterResolver {
+
+    @Override
+    public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
+        return parameterContext.isAnnotated(Captor.class);
+    }
+
+    @Override
+    public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
+        return CaptorAnnotationProcessor.process(parameterContext.getParameter());
+    }
+}
diff --git a/...-jupiter/src/main/java/org/mockito/junit/jupiter/resolver/CompositeParameterResolver.java b/...-jupiter/src/main/java/org/mockito/junit/jupiter/resolver/CompositeParameterResolver.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.junit.jupiter.resolver;
+
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
+
+import java.util.List;
+import java.util.Optional;
+
+public class CompositeParameterResolver implements ParameterResolver {
+
+    private final List<ParameterResolver> delegates;
+
+    public CompositeParameterResolver(final ParameterResolver... delegates) {
+        this.delegates = List.of(delegates);
+    }
+
+    @Override
+    public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
+        return findDelegate(parameterContext, extensionContext).isPresent();
+    }
+
+    @Override
+    @SuppressWarnings("OptionalGetWithoutIsPresent")
+    public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
+        final ParameterResolver delegate = findDelegate(parameterContext, extensionContext).get();
+        return delegate.resolveParameter(parameterContext, extensionContext);
+    }
+
+    private Optional<ParameterResolver> findDelegate(
+        final ParameterContext parameterContext,
+        final ExtensionContext extensionContext
+    ) {
+        return delegates.stream()
+            .filter(delegate -> delegate.supportsParameter(parameterContext, extensionContext))
+            .findFirst();
+    }
+}
diff --git a/...junit-jupiter/src/main/java/org/mockito/junit/jupiter/resolver/MockParameterResolver.java b/...junit-jupiter/src/main/java/org/mockito/junit/jupiter/resolver/MockParameterResolver.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.junit.jupiter.resolver;
+
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
+import org.mockito.Mock;
+import org.mockito.internal.configuration.MockAnnotationProcessor;
+
+import java.lang.reflect.Parameter;
+
+public class MockParameterResolver implements ParameterResolver {
+
+    @Override
+    public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext context) throws ParameterResolutionException {
+        return parameterContext.isAnnotated(Mock.class);
+    }
+
+    @Override
+    @SuppressWarnings("OptionalGetWithoutIsPresent")
+    public Object resolveParameter(ParameterContext parameterContext, ExtensionContext context) throws ParameterResolutionException {
+        final Parameter parameter = parameterContext.getParameter();
+
+        return MockAnnotationProcessor.processAnnotationForMock(
+            parameterContext.findAnnotation(Mock.class).get(),
+            parameter.getType(),
+            parameter::getParameterizedType,
+            parameter.getName());
+    }
+}