Support @⁠MockitoBean at the type level

Proof of Concept

See spring-projectsgh-33925

Author: sbrannen

spring-test/src/main/java/org/springframework/test/context/bean/override/BeanOverrideBeanFactoryPostProcessor.java

@@ -328,6 +328,7 @@ else if (candidateCount == 0) {
 	private Set<String> getExistingBeanNamesByType(ConfigurableListableBeanFactory beanFactory, BeanOverrideHandler handler,
 			boolean checkAutowiredCandidate) {
 
+		Field field = handler.getField();
 		ResolvableType resolvableType = handler.getBeanType();
 		Class<?> type = resolvableType.toClass();
 
@@ -345,16 +346,16 @@ private Set<String> getExistingBeanNamesByType(ConfigurableListableBeanFactory b
 		}
 
 		// Filter out non-matching autowire candidates.
-		if (checkAutowiredCandidate) {
-			DependencyDescriptor descriptor = new DependencyDescriptor(handler.getField(), true);
+		if (field != null && checkAutowiredCandidate) {
+			DependencyDescriptor descriptor = new DependencyDescriptor(field, true);
 			beanNames.removeIf(beanName -> !beanFactory.isAutowireCandidate(beanName, descriptor));
 		}
 		// Filter out scoped proxy targets.
 		beanNames.removeIf(ScopedProxyUtils::isScopedTarget);
 
 		// In case of multiple matches, fall back on the field's name as a last resort.
-		if (beanNames.size() > 1) {
-			String fieldName = handler.getField().getName();
+		if (field != null && beanNames.size() > 1) {
+			String fieldName = field.getName();
 			if (beanNames.contains(fieldName)) {
 				return Set.of(fieldName);
 			}

spring-test/src/main/java/org/springframework/test/context/bean/override/BeanOverrideContextCustomizerFactory.java

@@ -52,11 +52,8 @@ public BeanOverrideContextCustomizer createContextCustomizer(Class<?> testClass,
 	}
 
 	private void findBeanOverrideHandlers(Class<?> testClass, Set<BeanOverrideHandler> handlers) {
-		if (TestContextAnnotationUtils.searchEnclosingClass(testClass)) {
-			findBeanOverrideHandlers(testClass.getEnclosingClass(), handlers);
-		}
-		BeanOverrideHandler.forTestClass(testClass).forEach(handler ->
-				Assert.state(handlers.add(handler), () ->
+		BeanOverrideHandler.forTestClass(testClass, TestContextAnnotationUtils::searchEnclosingClass)
+				.forEach(handler -> Assert.state(handlers.add(handler), () ->
 						"Duplicate BeanOverrideHandler discovered in test class %s: %s"
 							.formatted(testClass.getName(), handler)));
 	}

spring-test/src/main/java/org/springframework/test/context/bean/override/BeanOverrideHandler.java

@@ -17,6 +17,7 @@
 package org.springframework.test.context.bean.override;
 
 import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedElement;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.util.Arrays;
@@ -27,6 +28,8 @@
 import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.BiConsumer;
+import java.util.function.Predicate;
 
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.config.BeanDefinition;
@@ -70,6 +73,7 @@
  */
 public abstract class BeanOverrideHandler {
 
+	@Nullable
 	private final Field field;
 
 	private final Set<Annotation> fieldAnnotations;
@@ -82,7 +86,7 @@ public abstract class BeanOverrideHandler {
 	private final BeanOverrideStrategy strategy;
 
 
-	protected BeanOverrideHandler(Field field, ResolvableType beanType, @Nullable String beanName,
+	protected BeanOverrideHandler(@Nullable Field field, ResolvableType beanType, @Nullable String beanName,
 			BeanOverrideStrategy strategy) {
 
 		this.field = field;
@@ -102,34 +106,78 @@ protected BeanOverrideHandler(Field field, ResolvableType beanType, @Nullable St
 	 * @see org.springframework.test.context.TestContextAnnotationUtils#searchEnclosingClass(Class)
 	 */
 	public static List<BeanOverrideHandler> forTestClass(Class<?> testClass) {
+		return forTestClass(testClass, clazz -> false);
+	}
+
+	public static List<BeanOverrideHandler> forTestClass(Class<?> testClass, Predicate<Class<?>> searchEnclosingClass) {
 		List<BeanOverrideHandler> handlers = new LinkedList<>();
-		ReflectionUtils.doWithFields(testClass, field -> processField(field, testClass, handlers));
+		findHandlers(testClass, testClass, handlers, searchEnclosingClass);
 		return handlers;
 	}
 
+	private static void findHandlers(Class<?> clazz, Class<?> testClass, List<BeanOverrideHandler> handlers,
+			Predicate<Class<?>> searchEnclosingClass) {
+
+		if (clazz == null || Object.class == clazz) {
+			return;
+		}
+
+		// 1) Search enclosing class hierarchy.
+		if (searchEnclosingClass.test(clazz)) {
+			findHandlers(clazz.getEnclosingClass(), testClass, handlers, searchEnclosingClass);
+		}
+
+		// 2) Search type hierarchy.
+		findHandlers(clazz.getSuperclass(), testClass, handlers, searchEnclosingClass);
+
+		// 3) Search interfaces.
+		for (Class<?> ifc : clazz.getInterfaces()) {
+			findHandlers(ifc, testClass, handlers, searchEnclosingClass);
+		}
+
+		// 4) Process current class.
+		processClass(clazz, testClass, handlers);
+
+		// 5) Process fields in current class.
+		ReflectionUtils.doWithLocalFields(clazz, field -> processField(field, testClass, handlers));
+	}
+
+	private static void processClass(Class<?> clazz, Class<?> testClass, List<BeanOverrideHandler> handlers) {
+		processElement(clazz, testClass, (processor, composedAnnotation) -> {
+			processor.createHandlers(composedAnnotation, testClass).forEach(handlers::add);
+		});
+	}
+
 	private static void processField(Field field, Class<?> testClass, List<BeanOverrideHandler> handlers) {
 		AtomicBoolean overrideAnnotationFound = new AtomicBoolean();
-		MergedAnnotations.from(field, DIRECT).stream(BeanOverride.class).forEach(mergedAnnotation -> {
+		processElement(field, testClass, (processor, composedAnnotation) -> {
 			Assert.state(!Modifier.isStatic(field.getModifiers()),
 					() -> "@BeanOverride field must not be static: " + field);
+			Assert.state(overrideAnnotationFound.compareAndSet(false, true),
+					() -> "Multiple @BeanOverride annotations found on field: " + field);
+			handlers.add(processor.createHandler(composedAnnotation, testClass, field));
+		});
+	}
+
+	private static void processElement(AnnotatedElement element, Class<?> testClass,
+			BiConsumer<BeanOverrideProcessor, Annotation> consumer) {
+
+		MergedAnnotations.from(element, DIRECT).stream(BeanOverride.class).forEach(mergedAnnotation -> {
 			MergedAnnotation<?> metaSource = mergedAnnotation.getMetaSource();
 			Assert.state(metaSource != null, "@BeanOverride annotation must be meta-present");
 
 			BeanOverride beanOverride = mergedAnnotation.synthesize();
 			BeanOverrideProcessor processor = BeanUtils.instantiateClass(beanOverride.value());
 			Annotation composedAnnotation = metaSource.synthesize();
-
-			Assert.state(overrideAnnotationFound.compareAndSet(false, true),
-					() -> "Multiple @BeanOverride annotations found on field: " + field);
-			BeanOverrideHandler handler = processor.createHandler(composedAnnotation, testClass, field);
-			handlers.add(handler);
+			consumer.accept(processor, composedAnnotation);
 		});
 	}
 
 
 	/**
 	 * Get the annotated {@link Field}.
 	 */
+	@Nullable
 	public final Field getField() {
 		return this.field;
 	}
@@ -231,15 +279,16 @@ public boolean equals(Object other) {
 		}
 
 		// by-type lookup
-		return (Objects.equals(this.field.getName(), that.field.getName()) &&
+		return (this.field != null && that.field != null &&
+				Objects.equals(this.field.getName(), that.field.getName()) &&
 				this.fieldAnnotations.equals(that.fieldAnnotations));
 	}
 
 	@Override
 	public int hashCode() {
 		int hash = Objects.hash(getClass(), this.beanType.getType(), this.beanName, this.strategy);
-		return (this.beanName != null ? hash : hash +
-				Objects.hash(this.field.getName(), this.fieldAnnotations));
+		return (this.beanName != null ? hash :
+				hash + Objects.hash((this.field != null ? this.field.getName() : ""), this.fieldAnnotations));
 	}
 
 	@Override
@@ -252,7 +301,10 @@ public String toString() {
 				.toString();
 	}
 
-	private static Set<Annotation> annotationSet(Field field) {
+	private static Set<Annotation> annotationSet(@Nullable Field field) {
+		if (field == null) {
+			return Collections.emptySet();
+		}
 		Annotation[] annotations = field.getAnnotations();
 		return (annotations.length != 0 ? new HashSet<>(Arrays.asList(annotations)) : Collections.emptySet());
 	}

spring-test/src/main/java/org/springframework/test/context/bean/override/BeanOverrideProcessor.java

@@ -18,6 +18,7 @@
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Field;
+import java.util.List;
 
 /**
  * Strategy interface for Bean Override processing, which creates a
@@ -36,7 +37,6 @@
  * @author Sam Brannen
  * @since 6.2
  */
-@FunctionalInterface
 public interface BeanOverrideProcessor {
 
 	/**
@@ -49,4 +49,8 @@ public interface BeanOverrideProcessor {
 	 */
 	BeanOverrideHandler createHandler(Annotation overrideAnnotation, Class<?> testClass, Field field);
 
+	default List<BeanOverrideHandler> createHandlers(Annotation overrideAnnotation, Class<?> testClass) {
+		return List.of();
+	}
+
 }

spring-test/src/main/java/org/springframework/test/context/bean/override/BeanOverrideTestExecutionListener.java

@@ -88,7 +88,9 @@ private static void injectFields(TestContext testContext) {
 					.getBean(BeanOverrideContextCustomizer.REGISTRY_BEAN_NAME, BeanOverrideRegistry.class);
 
 			for (BeanOverrideHandler handler : handlers) {
-				beanOverrideRegistry.inject(testInstance, handler);
+				if (handler.getField() != null) {
+					beanOverrideRegistry.inject(testInstance, handler);
+				}
 			}
 		}
 	}

spring-test/src/main/java/org/springframework/test/context/bean/override/mockito/AbstractMockitoBeanOverrideHandler.java

@@ -38,7 +38,7 @@ abstract class AbstractMockitoBeanOverrideHandler extends BeanOverrideHandler {
 	private final MockReset reset;
 
 
-	protected AbstractMockitoBeanOverrideHandler(Field field, ResolvableType beanType,
+	protected AbstractMockitoBeanOverrideHandler(@Nullable Field field, ResolvableType beanType,
 			@Nullable String beanName, BeanOverrideStrategy strategy, @Nullable MockReset reset) {
 
 		super(field, beanType, beanName, strategy);
@@ -56,20 +56,20 @@ MockReset getReset() {
 
 	@Override
 	protected void trackOverrideInstance(Object mock, SingletonBeanRegistry trackingBeanRegistry) {
-		getMockitoBeans(trackingBeanRegistry).add(mock);
+		getMockBeans(trackingBeanRegistry).add(mock);
 	}
 
-	private static MockitoBeans getMockitoBeans(SingletonBeanRegistry trackingBeanRegistry) {
-		String beanName = MockitoBeans.class.getName();
-		MockitoBeans mockitoBeans = null;
+	private static MockBeans getMockBeans(SingletonBeanRegistry trackingBeanRegistry) {
+		String beanName = MockBeans.class.getName();
+		MockBeans mockBeans = null;
 		if (trackingBeanRegistry.containsSingleton(beanName)) {
-			mockitoBeans = (MockitoBeans) trackingBeanRegistry.getSingleton(beanName);
+			mockBeans = (MockBeans) trackingBeanRegistry.getSingleton(beanName);
 		}
-		if (mockitoBeans == null) {
-			mockitoBeans = new MockitoBeans();
-			trackingBeanRegistry.registerSingleton(beanName, mockitoBeans);
+		if (mockBeans == null) {
+			mockBeans = new MockBeans();
+			trackingBeanRegistry.registerSingleton(beanName, mockBeans);
 		}
-		return mockitoBeans;
+		return mockBeans;
 	}
 
 	@Override

spring-test/src/main/java/org/springframework/test/context/bean/override/mockito/MockBeans.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2002-2024 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.bean.override.mockito;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.mockito.Mockito;
+
+/**
+ * Beans created using Mockito.
+ *
+ * @author Andy Wilkinson
+ * @author Sam Brannen
+ * @since 6.2
+ */
+class MockBeans {
+
+	private final List<Object> beans = new ArrayList<>();
+
+
+	void add(Object bean) {
+		this.beans.add(bean);
+	}
+
+	/**
+	 * Reset all Mockito beans configured with the supplied {@link MockReset} strategy.
+	 * <p>No mocks will be reset if the supplied strategy is {@link MockReset#NONE}.
+	 */
+	void resetAll(MockReset reset) {
+		if (reset != MockReset.NONE) {
+			for (Object bean : this.beans) {
+				if (reset == MockReset.get(bean)) {
+					Mockito.reset(bean);
+				}
+			}
+		}
+	}
+
+}

spring-test/src/main/java/org/springframework/test/context/bean/override/mockito/MockitoBean.java

@@ -18,6 +18,7 @@
 
 import java.lang.annotation.Documented;
 import java.lang.annotation.ElementType;
+import java.lang.annotation.Repeatable;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
@@ -69,9 +70,10 @@
  * @see org.springframework.test.context.bean.override.mockito.MockitoSpyBean @MockitoSpyBean
  * @see org.springframework.test.context.bean.override.convention.TestBean @TestBean
  */
-@Target(ElementType.FIELD)
+@Target({ElementType.FIELD, ElementType.TYPE})
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
+@Repeatable(MockitoBeans.class)
 @BeanOverride(MockitoBeanOverrideProcessor.class)
 public @interface MockitoBean {
 
@@ -94,6 +96,18 @@
 	@AliasFor("value")
 	String name() default "";
 
+	/**
+	 * The types to mock.
+	 * <p>Defaults to none.
+	 * <p>Each type specified here will result in a mock being created and
+	 * registered with the {@code ApplicationContext}.
+	 * <p>Types must be omitted when the annotation is used on a field.
+	 * <p>When {@code @MockitoBean} also defines a {@link #name} this attribute
+	 * can only contain a single value.
+	 * @return the types to mock
+	 */
+	Class<?>[] types() default {};
+
 	/**
 	 * Extra interfaces that should also be declared by the mock.
 	 * <p>Defaults to none.

spring-test/src/main/java/org/springframework/test/context/bean/override/mockito/MockitoBeanOverrideHandler.java

@@ -57,7 +57,7 @@ class MockitoBeanOverrideHandler extends AbstractMockitoBeanOverrideHandler {
 	private final boolean serializable;
 
 
-	MockitoBeanOverrideHandler(Field field, ResolvableType typeToMock, MockitoBean mockitoBean) {
+	MockitoBeanOverrideHandler(@Nullable Field field, ResolvableType typeToMock, MockitoBean mockitoBean) {
 		this(field, typeToMock, (!mockitoBean.name().isBlank() ? mockitoBean.name() : null),
 			(mockitoBean.enforceOverride() ? REPLACE : REPLACE_OR_CREATE),
 			mockitoBean.reset(), mockitoBean.extraInterfaces(), mockitoBean.answers(), mockitoBean.serializable());