Remove TestOverrideMetadata and use dummy implementation

TestOverrideMetadata was doing byName lookup by default, even without
a bean name. This makes writing tests that need to do by type lookup
way more complicated that it should.

This commit introduces DummyBean, that merely replaces two types with
hardcoded values. It also exposes the raw attribute of OverrideMetadata
and doesn't override anything from it to make sure the behavior is not
altered.

Closes gh-32982

Author: snicoll

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

@@ -33,16 +33,10 @@
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.beans.factory.support.RootBeanDefinition;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
 import org.springframework.context.support.SimpleThreadScope;
 import org.springframework.core.Ordered;
 import org.springframework.core.ResolvableType;
 import org.springframework.test.context.MergedContextConfiguration;
-import org.springframework.test.context.bean.override.example.ExampleBeanOverrideAnnotation;
-import org.springframework.test.context.bean.override.example.ExampleService;
-import org.springframework.test.context.bean.override.example.FailingExampleService;
-import org.springframework.test.context.bean.override.example.RealExampleService;
 import org.springframework.test.util.ReflectionTestUtils;
 import org.springframework.util.Assert;
 
@@ -56,123 +50,123 @@
  * {@link BeanOverrideRegistrar}.
  *
  * @author Simon Baslé
+ * @author Stephane Nicoll
  */
 class BeanOverrideBeanFactoryPostProcessorTests {
 
 	@Test
 	void canReplaceExistingBeanDefinitions() {
-		AnnotationConfigApplicationContext context = createContext(ReplaceBeans.class);
-		context.register(ReplaceBeans.class);
-		context.registerBean("explicit", ExampleService.class, () -> new RealExampleService("unexpected"));
-		context.registerBean("implicitName", ExampleService.class, () -> new RealExampleService("unexpected"));
-
+		AnnotationConfigApplicationContext context = createContext(CaseByNameAndByType.class);
+		context.registerBean("descriptionBean", String.class, () -> "Original");
+		context.registerBean("someInteger", Integer.class, () -> 1);
 		context.refresh();
 
-		assertThat(context.getBean("explicit")).isSameAs(OVERRIDE_SERVICE);
-		assertThat(context.getBean("implicitName")).isSameAs(OVERRIDE_SERVICE);
+		assertThat(context.getBean("descriptionBean")).isEqualTo("overridden");
+		assertThat(context.getBean("someInteger")).isSameAs(42);
 	}
 
 	@Test
-	void cannotReplaceIfNoBeanMatching() {
-		AnnotationConfigApplicationContext context = createContext(ReplaceBeans.class);
-		context.register(ReplaceBeans.class);
-		//note we don't register any original bean here
+	void cannotReplaceIfNoBeanNameMatching() {
+		AnnotationConfigApplicationContext context = createContext(CaseByName.class);
 
 		assertThatIllegalStateException()
 				.isThrownBy(context::refresh)
-				.withMessage("Unable to override bean 'explicit': there is no bean definition " +
-						"to replace with that name of type org.springframework.test.context.bean.override.example.ExampleService");
+				.withMessage("Unable to override bean 'descriptionBean': there is no bean definition " +
+						"to replace with that name of type java.lang.String");
 	}
 
 	@Test
-	void canReplaceExistingBeanDefinitionsWithCreateReplaceStrategy() {
-		AnnotationConfigApplicationContext context = createContext(CreateIfOriginalIsMissingBean.class);
-		context.register(CreateIfOriginalIsMissingBean.class);
-		context.registerBean("explicit", ExampleService.class, () -> new RealExampleService("unexpected"));
-		context.registerBean("implicitName", ExampleService.class, () -> new RealExampleService("unexpected"));
+	void cannotReplaceIfNoBeanTypeMatching() {
+		AnnotationConfigApplicationContext context = createContext(CaseByType.class);
 
+		assertThatIllegalStateException()
+				.isThrownBy(context::refresh)
+				.withMessage("Unable to override bean: no bean definitions of type java.lang.Integer " +
+						"(as required by annotated field 'CaseByType.counter')");
+	}
+
+	@Test
+	void canReplaceExistingBeanDefinitionsWithCreateReplaceStrategy() {
+		AnnotationConfigApplicationContext context = createContext(CaseByNameAndByTypeWithReplaceOrCreateStrategy.class);
+		context.register(CaseByNameAndByTypeWithReplaceOrCreateStrategy.class);
+		context.registerBean("descriptionBean", String.class, () -> "Original");
+		context.registerBean("someInteger", Integer.class, () -> 1);
 		context.refresh();
 
-		assertThat(context.getBean("explicit")).isSameAs(OVERRIDE_SERVICE);
-		assertThat(context.getBean("implicitName")).isSameAs(OVERRIDE_SERVICE);
+		assertThat(context.getBean("descriptionBean")).isEqualTo("overridden");
+		assertThat(context.getBean("someInteger")).isEqualTo(42);
 	}
 
 	@Test
 	void canCreateIfOriginalMissingWithCreateReplaceStrategy() {
-		AnnotationConfigApplicationContext context = createContext(CreateIfOriginalIsMissingBean.class);
-		context.register(CreateIfOriginalIsMissingBean.class);
-		//note we don't register original beans here
-
+		AnnotationConfigApplicationContext context = createContext(CaseByNameAndByTypeWithReplaceOrCreateStrategy.class);
 		context.refresh();
 
-		assertThat(context.getBean("explicit")).isSameAs(OVERRIDE_SERVICE);
-		assertThat(context.getBean("implicitName")).isSameAs(OVERRIDE_SERVICE);
+		String byTypeGeneratedBeanName = "java.lang.Integer#0";
+		assertThat(context.getBeanDefinitionNames()).contains("descriptionBean", byTypeGeneratedBeanName);
+		assertThat(context.getBean("descriptionBean")).isEqualTo("overridden");
+		assertThat(context.getBean(byTypeGeneratedBeanName)).isEqualTo(42);
 	}
 
 	@Test
 	void canOverrideBeanProducedByFactoryBeanWithClassObjectTypeAttribute() {
-		AnnotationConfigApplicationContext context = createContext(OverriddenFactoryBean.class);
-		RootBeanDefinition factoryBeanDefinition = new RootBeanDefinition(TestFactoryBean.class);
-		factoryBeanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE, SomeInterface.class);
-		context.registerBeanDefinition("beanToBeOverridden", factoryBeanDefinition);
-		context.register(OverriddenFactoryBean.class);
-
+		AnnotationConfigApplicationContext context = prepareContextWithFactoryBean(CharSequence.class);
 		context.refresh();
 
-		assertThat(context.getBean("beanToBeOverridden")).isSameAs(OVERRIDE);
+		assertThat(context.getBean("beanToBeOverridden")).isEqualTo("overridden");
 	}
 
 	@Test
 	void canOverrideBeanProducedByFactoryBeanWithResolvableTypeObjectTypeAttribute() {
-		AnnotationConfigApplicationContext context = createContext(OverriddenFactoryBean.class);
-		RootBeanDefinition factoryBeanDefinition = new RootBeanDefinition(TestFactoryBean.class);
-		ResolvableType objectType = ResolvableType.forClass(SomeInterface.class);
-		factoryBeanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE, objectType);
-		context.registerBeanDefinition("beanToBeOverridden", factoryBeanDefinition);
-		context.register(OverriddenFactoryBean.class);
-
+		AnnotationConfigApplicationContext context = prepareContextWithFactoryBean(ResolvableType.forClass(CharSequence.class));
 		context.refresh();
 
-		assertThat(context.getBean("beanToBeOverridden")).isSameAs(OVERRIDE);
+		assertThat(context.getBean("beanToBeOverridden")).isEqualTo("overridden");
+	}
+
+	private AnnotationConfigApplicationContext prepareContextWithFactoryBean(Object objectTypeAttribute) {
+		AnnotationConfigApplicationContext context = createContext(CaseOverrideBeanProducedByFactoryBean.class);
+		context.registerBean("testFactoryBean", TestFactoryBean.class, TestFactoryBean::new);
+		RootBeanDefinition factoryBeanDefinition = new RootBeanDefinition(TestFactoryBean.class);
+		factoryBeanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE, objectTypeAttribute);
+		context.registerBeanDefinition("beanToBeOverridden", factoryBeanDefinition);
+		return context;
 	}
 
 	@Test
 	void postProcessorShouldNotTriggerEarlyInitialization() {
-		AnnotationConfigApplicationContext context = createContext(EagerInitBean.class);
+		AnnotationConfigApplicationContext context = createContext(CaseByTypeWithReplaceOrCreateStrategy.class);
 
 		context.register(FactoryBeanRegisteringPostProcessor.class);
 		context.register(EarlyBeanInitializationDetector.class);
-		context.register(EagerInitBean.class);
 
 		assertThatNoException().isThrownBy(context::refresh);
 	}
 
 	@Test
 	void allowReplaceDefinitionWhenSingletonDefinitionPresent() {
-		AnnotationConfigApplicationContext context = createContext(SingletonBean.class);
+		AnnotationConfigApplicationContext context = createContext(CaseByName.class);
 		RootBeanDefinition definition = new RootBeanDefinition(String.class, () -> "ORIGINAL");
 		definition.setScope(BeanDefinition.SCOPE_SINGLETON);
-		context.registerBeanDefinition("singleton", definition);
-		context.register(SingletonBean.class);
+		context.registerBeanDefinition("descriptionBean", definition);
 
 		assertThatNoException().isThrownBy(context::refresh);
-		assertThat(context.isSingleton("singleton")).as("isSingleton").isTrue();
-		assertThat(context.getBean("singleton")).as("overridden").isEqualTo("USED THIS");
+		assertThat(context.isSingleton("descriptionBean")).as("isSingleton").isTrue();
+		assertThat(context.getBean("descriptionBean")).isEqualTo("overridden");
 	}
 
 	@Test
 	void copyDefinitionPrimaryFallbackAndScope() {
-		AnnotationConfigApplicationContext context = createContext(SingletonBean.class);
+		AnnotationConfigApplicationContext context = createContext(CaseByName.class);
 		context.getBeanFactory().registerScope("customScope", new SimpleThreadScope());
 		RootBeanDefinition definition = new RootBeanDefinition(String.class, () -> "ORIGINAL");
 		definition.setScope("customScope");
 		definition.setPrimary(true);
 		definition.setFallback(true);
-		context.registerBeanDefinition("singleton", definition);
-		context.register(SingletonBean.class);
+		context.registerBeanDefinition("descriptionBean", definition);
 
 		assertThatNoException().isThrownBy(context::refresh);
-		assertThat(context.getBeanDefinition("singleton"))
+		assertThat(context.getBeanDefinition("descriptionBean"))
 				.isNotSameAs(definition)
 				.matches(BeanDefinition::isPrimary, "isPrimary")
 				.matches(BeanDefinition::isFallback, "isFallback")
@@ -183,22 +177,20 @@ void copyDefinitionPrimaryFallbackAndScope() {
 
 	@Test
 	void createDefinitionShouldSetQualifierElement() {
-		AnnotationConfigApplicationContext context = createContext(QualifiedBean.class);
-		context.registerBeanDefinition("singleton", new RootBeanDefinition(String.class, () -> "ORIGINAL"));
-		context.register(QualifiedBean.class);
+		AnnotationConfigApplicationContext context = createContext(CaseByNameWithQualifier.class);
+		context.registerBeanDefinition("descriptionBean", new RootBeanDefinition(String.class, () -> "ORIGINAL"));
 
 		assertThatNoException().isThrownBy(context::refresh);
-
-		assertThat(context.getBeanDefinition("singleton"))
+		assertThat(context.getBeanDefinition("descriptionBean"))
 				.isInstanceOfSatisfying(RootBeanDefinition.class, this::isTheValueField);
 	}
 
 
 	private void isTheValueField(RootBeanDefinition def) {
 		assertThat(def.getQualifiedElement()).isInstanceOfSatisfying(Field.class, field -> {
-					assertThat(field.getDeclaringClass()).isEqualTo(QualifiedBean.class);
+					assertThat(field.getDeclaringClass()).isEqualTo(CaseByNameWithQualifier.class);
 					assertThat(field.getName()).as("annotated field name")
-							.isEqualTo("value");
+							.isEqualTo("description");
 				});
 	}
 
@@ -210,99 +202,67 @@ private AnnotationConfigApplicationContext createContext(Class<?> testClass) {
 	}
 
 
-	/*
-		Classes to parse and register with the bean post processor
-		-----
-		Note that some of these are both a @Configuration class and bean override field holder.
-		This is for this test convenience, as typically the bean override annotated fields
-		should not be in configuration classes but rather in test case classes
-		(where a TestExecutionListener automatically discovers and parses them).
-	 */
+	static class CaseByName {
 
-	static final SomeInterface OVERRIDE = new SomeImplementation();
+		@DummyBean(beanName = "descriptionBean")
+		private String description;
 
-	static final ExampleService OVERRIDE_SERVICE = new FailingExampleService();
-
-	static class ReplaceBeans {
+	}
 
-		@ExampleBeanOverrideAnnotation(value = "useThis", beanName = "explicit")
-		private ExampleService explicitName;
+	static class CaseByType {
 
-		@ExampleBeanOverrideAnnotation(value = "useThis")
-		private ExampleService implicitName;
+		@DummyBean
+		private Integer counter;
 
-		static ExampleService useThis() {
-			return OVERRIDE_SERVICE;
-		}
 	}
 
-	static class CreateIfOriginalIsMissingBean {
+	static class CaseByNameAndByType {
 
-		@ExampleBeanOverrideAnnotation(value = "useThis", createIfMissing = true, beanName = "explicit")
-		private ExampleService explicitName;
+		@DummyBean(beanName = "descriptionBean")
+		private String description;
 
-		@ExampleBeanOverrideAnnotation(value = "useThis", createIfMissing = true)
-		private ExampleService implicitName;
+		@DummyBean
+		private Integer counter;
 
-		static ExampleService useThis() {
-			return OVERRIDE_SERVICE;
-		}
 	}
 
-	@Configuration(proxyBeanMethods = false)
-	static class OverriddenFactoryBean {
+	static class CaseByTypeWithReplaceOrCreateStrategy {
 
-		@ExampleBeanOverrideAnnotation(value = "fOverride", beanName = "beanToBeOverridden")
-		SomeInterface f;
-
-		static SomeInterface fOverride() {
-			return OVERRIDE;
-		}
+		@DummyBean(strategy = BeanOverrideStrategy.REPLACE_OR_CREATE_DEFINITION)
+		private String description;
 
-		@Bean
-		TestFactoryBean testFactoryBean() {
-			return new TestFactoryBean();
-		}
 	}
 
-	static class EagerInitBean {
+	static class CaseByNameAndByTypeWithReplaceOrCreateStrategy {
 
-		@ExampleBeanOverrideAnnotation(value = "useThis", createIfMissing = true)
-		private ExampleService service;
+		@DummyBean(beanName = "descriptionBean", strategy = BeanOverrideStrategy.REPLACE_OR_CREATE_DEFINITION)
+		private String description;
+
+		@DummyBean(strategy = BeanOverrideStrategy.REPLACE_OR_CREATE_DEFINITION)
+		private Integer counter;
 
-		static ExampleService useThis() {
-			return OVERRIDE_SERVICE;
-		}
 	}
 
-	static class SingletonBean {
+	static class CaseOverrideBeanProducedByFactoryBean {
 
-		@ExampleBeanOverrideAnnotation(beanName = "singleton",
-				value = "useThis", createIfMissing = false)
-		private String value;
+		@DummyBean(beanName = "beanToBeOverridden")
+		CharSequence description;
 
-		static String useThis() {
-			return "USED THIS";
-		}
 	}
 
-	static class QualifiedBean {
+	static class CaseByNameWithQualifier {
 
 		@Qualifier("preferThis")
-		@ExampleBeanOverrideAnnotation(beanName = "singleton",
-				value = "useThis", createIfMissing = false)
-		private String value;
+		@DummyBean(beanName = "descriptionBean")
+		private String description;
 
-		static String useThis() {
-			return "USED THIS";
-		}
 	}
 
 	static class TestFactoryBean implements FactoryBean<Object> {
 
 		@Override
 		public Object getObject() {
-			return new SomeImplementation();
+			return "test";
 		}
 
 		@Override
@@ -341,10 +301,4 @@ public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
 		}
 	}
 
-	interface SomeInterface {
-	}
-
-	static class SomeImplementation implements SomeInterface {
-	}
-
 }