Review TCF cache support for bean override

This commit reviews how bean override support can influence the key of
an application context cached by the TCF. OverrideMetadata and its
subclasses now implement a proper equals/hashCode pair that is tested
in various scenarios.

Due to how the TCF operates, OverrideMetadata has to be computed in
two locations:

1. In a ContextCustomizerFactory, using the metadata in the enclosing
class if any. This determines whether a customizer is needed in the
first place. The computed set of unique metadata identifies the
customizer and participates in the application context cache's key.
2. In the TestExecutionListener so that it knows the override points
it has to process.

Parsing of the metadata based on a test class has been greatly
simplified and moved to OverrideMetadata proper as we don't need several
flavors. 1 and 2 are using the same algorithm with the former wrapping
that in a Set to compute a proper key.

BeanOverrideContextCustomizerEqualityTests provides a framework for
testing edge cases as we only care about whether the created
ContextCustomizer behaves correctly against the identity of another.

Closes gh-32884

Author: snicoll

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

@@ -41,38 +41,41 @@
 import org.springframework.util.StringUtils;
 
 /**
- * A {@link BeanFactoryPostProcessor} implementation that processes test classes
- * and adapts the {@link BeanFactory} for any {@link BeanOverride} it may define.
+ * A {@link BeanFactoryPostProcessor} implementation that processes identified
+ * use of {@link BeanOverride} and adapts the {@link BeanFactory} accordingly.
  *
- * <p>A set of classes from which to parse {@link OverrideMetadata} must be
- * provided to this processor. Each test class is expected to use any
- * annotation meta-annotated with {@link BeanOverride @BeanOverride} to mark
- * beans to override. The {@link BeanOverrideParsingUtils#hasBeanOverride(Class)}
- * method can be used to check if a class matches the above criteria.
+ * <p>For each override, the bean factory is prepared according to the chosen
+ * {@link BeanOverrideStrategy overriding strategy}. The override value is created,
+ * if necessary, and the necessary infrastructure is updated to allow the value
+ * to be injected in the corresponding {@linkplain OverrideMetadata#getField() field}
+ * of the test class.
  *
- * <p>The provided classes are fully parsed at creation to build a metadata set.
- * This processor implements several {@link BeanOverrideStrategy overriding
- * strategies} and chooses the correct one according to each override metadata's
- * {@link OverrideMetadata#getStrategy()} method. Additionally, it provides
- * support for injecting the overridden bean instances into their corresponding
- * annotated {@link Field fields}.
+ * <p>This processor does not work against a particular test class, it only prepares
+ * the bean factory for the identified, unique, set of bean overrides.
  *
  * @author Simon Baslé
+ * @author Stephane Nicoll
  * @since 6.2
  */
 class BeanOverrideBeanFactoryPostProcessor implements BeanFactoryPostProcessor, Ordered {
 
+	private final Set<OverrideMetadata> metadata;
+
 	private final BeanOverrideRegistrar overrideRegistrar;
 
 
 	/**
 	 * Create a new {@code BeanOverrideBeanFactoryPostProcessor} instance with
-	 * the given {@link BeanOverrideRegistrar}, which contains a set of parsed
-	 * {@link OverrideMetadata}.
+	 * the set of {@link OverrideMetadata} to process, using the given
+	 * {@link BeanOverrideRegistrar}.
+	 * @param metadata the {@link OverrideMetadata} instances to process
 	 * @param overrideRegistrar the {@link BeanOverrideRegistrar} used to track
 	 * metadata
 	 */
-	public BeanOverrideBeanFactoryPostProcessor(BeanOverrideRegistrar overrideRegistrar) {
+	public BeanOverrideBeanFactoryPostProcessor(Set<OverrideMetadata> metadata,
+			BeanOverrideRegistrar overrideRegistrar) {
+
+		this.metadata = metadata;
 		this.overrideRegistrar = overrideRegistrar;
 	}
 
@@ -92,7 +95,7 @@ public int getOrder() {
 	}
 
 	private void postProcessWithRegistry(ConfigurableListableBeanFactory beanFactory, BeanDefinitionRegistry registry) {
-		for (OverrideMetadata metadata : this.overrideRegistrar.getOverrideMetadata()) {
+		for (OverrideMetadata metadata : this.metadata) {
 			registerBeanOverride(beanFactory, registry, metadata);
 		}
 	}

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

@@ -49,10 +49,10 @@ class BeanOverrideContextCustomizer implements ContextCustomizer {
 			"org.springframework.test.context.bean.override.internalWrapEarlyBeanPostProcessor";
 
 
-	private final Set<Class<?>> detectedClasses;
+	private final Set<OverrideMetadata> metadata;
 
-	BeanOverrideContextCustomizer(Set<Class<?>> detectedClasses) {
-		this.detectedClasses = detectedClasses;
+	BeanOverrideContextCustomizer(Set<OverrideMetadata> metadata) {
+		this.metadata = metadata;
 	}
 
 	@Override
@@ -61,19 +61,25 @@ public void customizeContext(ConfigurableApplicationContext context, MergedConte
 			throw new IllegalStateException("Cannot process bean overrides with an ApplicationContext " +
 					"that doesn't implement BeanDefinitionRegistry: " + context.getClass());
 		}
-		registerInfrastructure(registry, this.detectedClasses);
+		registerInfrastructure(registry);
 	}
 
-	private void registerInfrastructure(BeanDefinitionRegistry registry, Set<Class<?>> detectedClasses) {
+	Set<OverrideMetadata> getMetadata() {
+		return this.metadata;
+	}
+
+	private void registerInfrastructure(BeanDefinitionRegistry registry) {
 		addInfrastructureBeanDefinition(registry, BeanOverrideRegistrar.class, REGISTRAR_BEAN_NAME,
-				constructorArgs -> constructorArgs.addIndexedArgumentValue(0, detectedClasses));
+				constructorArgs -> {});
+
 		RuntimeBeanReference registrarReference = new RuntimeBeanReference(REGISTRAR_BEAN_NAME);
-		addInfrastructureBeanDefinition(
-				registry, WrapEarlyBeanPostProcessor.class, EARLY_INFRASTRUCTURE_BEAN_NAME,
-				constructorArgs -> constructorArgs.addIndexedArgumentValue(0, registrarReference));
-		addInfrastructureBeanDefinition(
-				registry, BeanOverrideBeanFactoryPostProcessor.class, INFRASTRUCTURE_BEAN_NAME,
+		addInfrastructureBeanDefinition(registry, WrapEarlyBeanPostProcessor.class, EARLY_INFRASTRUCTURE_BEAN_NAME,
 				constructorArgs -> constructorArgs.addIndexedArgumentValue(0, registrarReference));
+		addInfrastructureBeanDefinition(registry, BeanOverrideBeanFactoryPostProcessor.class, INFRASTRUCTURE_BEAN_NAME,
+				constructorArgs -> {
+					constructorArgs.addIndexedArgumentValue(0, this.metadata);
+					constructorArgs.addIndexedArgumentValue(1, registrarReference);
+				});
 	}
 
 	private void addInfrastructureBeanDefinition(BeanDefinitionRegistry registry,
@@ -97,12 +103,12 @@ public boolean equals(Object other) {
 			return false;
 		}
 		BeanOverrideContextCustomizer that = (BeanOverrideContextCustomizer) other;
-		return this.detectedClasses.equals(that.detectedClasses);
+		return this.metadata.equals(that.metadata);
 	}
 
 	@Override
 	public int hashCode() {
-		return this.detectedClasses.hashCode();
+		return this.metadata.hashCode();
 	}
 
 }

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

@@ -16,13 +16,12 @@
 
 package org.springframework.test.context.bean.override;
 
-import java.util.LinkedHashSet;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
 import org.springframework.lang.Nullable;
 import org.springframework.test.context.ContextConfigurationAttributes;
-import org.springframework.test.context.ContextCustomizer;
 import org.springframework.test.context.ContextCustomizerFactory;
 import org.springframework.test.context.TestContextAnnotationUtils;
 
@@ -31,31 +30,30 @@
  * Bean Overriding.
  *
  * @author Simon Baslé
+ * @author Stephane Nicoll
  * @since 6.2
  * @see BeanOverride
  */
 class BeanOverrideContextCustomizerFactory implements ContextCustomizerFactory {
 
 	@Override
 	@Nullable
-	public ContextCustomizer createContextCustomizer(Class<?> testClass,
+	public BeanOverrideContextCustomizer createContextCustomizer(Class<?> testClass,
 			List<ContextConfigurationAttributes> configAttributes) {
 
-		Set<Class<?>> detectedClasses = new LinkedHashSet<>();
-		findClassesWithBeanOverride(testClass, detectedClasses);
-		if (detectedClasses.isEmpty()) {
+		Set<OverrideMetadata> metadata = new HashSet<>();
+		findOverrideMetadata(testClass, metadata);
+		if (metadata.isEmpty()) {
 			return null;
 		}
-
-		return new BeanOverrideContextCustomizer(detectedClasses);
+		return new BeanOverrideContextCustomizer(metadata);
 	}
 
-	private void findClassesWithBeanOverride(Class<?> testClass, Set<Class<?>> detectedClasses) {
-		if (BeanOverrideParsingUtils.hasBeanOverride(testClass)) {
-			detectedClasses.add(testClass);
-		}
+	private void findOverrideMetadata(Class<?> testClass, Set<OverrideMetadata> metadata) {
+		List<OverrideMetadata> overrideMetadata = OverrideMetadata.forTestClass(testClass);
+		metadata.addAll(overrideMetadata);
 		if (TestContextAnnotationUtils.searchEnclosingClass(testClass)) {
-			findClassesWithBeanOverride(testClass.getEnclosingClass(), detectedClasses);
+			findOverrideMetadata(testClass.getEnclosingClass(), metadata);
 		}
 	}
 

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

@@ -19,7 +19,6 @@
 import java.lang.reflect.Field;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Set;
 
 import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.BeanCreationException;
@@ -45,21 +44,10 @@ class BeanOverrideRegistrar implements BeanFactoryAware {
 
 	private final Map<String, OverrideMetadata> earlyOverrideMetadata = new HashMap<>();
 
-	private final Set<OverrideMetadata> overrideMetadata;
-
 	@Nullable
 	private ConfigurableBeanFactory beanFactory;
 
 
-	/**
-	 * Create a new registrar and immediately parse the provided classes.
-	 * @param classesToParse the initial set of classes that have been
-	 * detected to contain bean overriding annotations
-	 */
-	BeanOverrideRegistrar(Set<Class<?>> classesToParse) {
-		this.overrideMetadata = BeanOverrideParsingUtils.parse(classesToParse);
-	}
-
 	@Override
 	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
 		if (!(beanFactory instanceof ConfigurableBeanFactory cbf)) {
@@ -69,13 +57,6 @@ public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
 		this.beanFactory = cbf;
 	}
 
-	/**
-	 * Get the detected {@link OverrideMetadata} instances.
-	 */
-	Set<OverrideMetadata> getOverrideMetadata() {
-		return this.overrideMetadata;
-	}
-
 	/**
 	 * Check {@link #markWrapEarly(OverrideMetadata, String) early override}
 	 * records and use the {@link OverrideMetadata} to create an override

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

@@ -17,6 +17,7 @@
 package org.springframework.test.context.bean.override;
 
 import java.lang.reflect.Field;
+import java.util.List;
 import java.util.function.BiConsumer;
 
 import org.springframework.test.context.TestContext;
@@ -74,12 +75,12 @@ protected void reinjectFieldsIfConfigured(TestContext testContext) throws Except
 		if (Boolean.TRUE.equals(
 				testContext.getAttribute(DependencyInjectionTestExecutionListener.REINJECT_DEPENDENCIES_ATTRIBUTE))) {
 
-			postProcessFields(testContext, (testMetadata, postProcessor) -> {
+			postProcessFields(testContext, (testMetadata, registrar) -> {
 				Object testInstance = testMetadata.testInstance;
 				Field field = testMetadata.overrideMetadata.getField();
 				ReflectionUtils.makeAccessible(field);
 				ReflectionUtils.setField(field, testInstance, null);
-				postProcessor.inject(testInstance, testMetadata.overrideMetadata);
+				registrar.inject(testInstance, testMetadata.overrideMetadata);
 			});
 		}
 	}
@@ -90,13 +91,11 @@ private void postProcessFields(TestContext testContext, BiConsumer<TestContextOv
 		Class<?> testClass = testContext.getTestClass();
 		Object testInstance = testContext.getTestInstance();
 
-		if (BeanOverrideParsingUtils.hasBeanOverride(testClass)) {
+		List<OverrideMetadata> metadataForFields = OverrideMetadata.forTestClass(testClass);
+		if (!metadataForFields.isEmpty()) {
 			BeanOverrideRegistrar registrar =
 					testContext.getApplicationContext().getBean(BeanOverrideRegistrar.class);
-			for (OverrideMetadata metadata : registrar.getOverrideMetadata()) {
-				if (!metadata.getField().getDeclaringClass().isAssignableFrom(testClass)) {
-					continue;
-				}
+			for (OverrideMetadata metadata : metadataForFields) {
 				consumer.accept(new TestContextOverrideMetadata(testInstance, metadata), registrar);
 			}
 		}