Remove extra "Bean" from TestBeanBeanOverrideHandler class name

The extra "Bean" was accidentally added in commit ebdf6dc2fc.

See gh-33702

Author: sbrannen

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

@@ -50,7 +50,8 @@
  * interfaces, the entire type hierarchy is searched. Alternatively, a factory
  * method in an external class can be referenced via its fully-qualified method
  * name following the syntax {@code <fully-qualified class name>#<method name>}
- * &mdash; for example, {@code "org.example.TestUtils#createCustomerRepository"}.
+ * &mdash; for example,
+ * {@code @TestBean(methodName = "org.example.TestUtils#createCustomerRepository")}.
  *
  * <p>The factory method is deduced as follows.
  *
@@ -144,7 +145,7 @@
 	 * <p>Alternatively, a factory method in an external class can be referenced
 	 * via its fully-qualified method name following the syntax
 	 * {@code <fully-qualified class name>#<method name>} &mdash; for example,
-	 * {@code "org.example.TestUtils#createCustomerRepository"}.
+	 * {@code @TestBean(methodName = "org.example.TestUtils#createCustomerRepository")}.
 	 * <p>If left unspecified, the name of the factory method will be detected
 	 * based either on the name of the annotated field or the name of the bean.
 	 */

spring-test/src/main/java/org/springframework/test/context/bean/override/convention/TestBeanBeanOverrideHandler.java renamed to spring-test/src/main/java/org/springframework/test/context/bean/override/convention/TestBeanOverrideHandler.java

@@ -29,19 +29,19 @@
 import org.springframework.util.ReflectionUtils;
 
 /**
- * {@link BeanOverrideHandler} implementation for {@link TestBean}.
+ * {@link BeanOverrideHandler} implementation for {@link TestBean @TestBean}.
  *
  * @author Simon Baslé
  * @author Stephane Nicoll
  * @author Sam Brannen
  * @since 6.2
  */
-final class TestBeanBeanOverrideHandler extends BeanOverrideHandler {
+final class TestBeanOverrideHandler extends BeanOverrideHandler {
 
 	private final Method factoryMethod;
 
 
-	TestBeanBeanOverrideHandler(Field field, ResolvableType beanType, @Nullable String beanName,
+	TestBeanOverrideHandler(Field field, ResolvableType beanType, @Nullable String beanName,
 			BeanOverrideStrategy strategy, Method factoryMethod) {
 
 		super(field, beanType, beanName, strategy);
@@ -74,7 +74,7 @@ public boolean equals(@Nullable Object other) {
 		if (!super.equals(other)) {
 			return false;
 		}
-		TestBeanBeanOverrideHandler that = (TestBeanBeanOverrideHandler) other;
+		TestBeanOverrideHandler that = (TestBeanOverrideHandler) other;
 		return Objects.equals(this.factoryMethod, that.factoryMethod);
 	}
 

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

@@ -42,7 +42,7 @@
 
 /**
  * {@link BeanOverrideProcessor} implementation for {@link TestBean @TestBean}
- * support, which creates a {@link TestBeanBeanOverrideHandler} for annotated
+ * support, which creates a {@link TestBeanOverrideHandler} for annotated
  * fields in a given class and ensures that a corresponding static factory method
  * exists, according to the {@linkplain TestBean documented conventions}.
  *
@@ -54,7 +54,7 @@
 class TestBeanOverrideProcessor implements BeanOverrideProcessor {
 
 	@Override
-	public TestBeanBeanOverrideHandler createHandler(Annotation overrideAnnotation, Class<?> testClass, Field field) {
+	public TestBeanOverrideHandler createHandler(Annotation overrideAnnotation, Class<?> testClass, Field field) {
 		if (!(overrideAnnotation instanceof TestBean testBean)) {
 			throw new IllegalStateException("Invalid annotation passed to %s: expected @TestBean on field %s.%s"
 					.formatted(getClass().getSimpleName(), field.getDeclaringClass().getName(), field.getName()));
@@ -81,7 +81,7 @@ public TestBeanBeanOverrideHandler createHandler(Annotation overrideAnnotation,
 			factoryMethod = findTestBeanFactoryMethod(testClass, field.getType(), candidateMethodNames);
 		}
 
-		return new TestBeanBeanOverrideHandler(
+		return new TestBeanOverrideHandler(
 				field, ResolvableType.forField(field, testClass), beanName, strategy, factoryMethod);
 	}
 

spring-test/src/test/java/org/springframework/test/context/bean/override/convention/TestBeanBeanOverrideHandlerTests.java renamed to spring-test/src/test/java/org/springframework/test/context/bean/override/convention/TestBeanOverrideHandlerTests.java

@@ -33,99 +33,102 @@
 import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
 
 /**
- * Tests for {@link TestBeanBeanOverrideHandler}.
+ * Tests for {@link TestBeanOverrideHandler}.
  *
  * @author Stephane Nicoll
+ * @author Sam Brannen
+ * @since 6.2
  */
-class TestBeanBeanOverrideHandlerTests {
+class TestBeanOverrideHandlerTests {
 
 	@Test
-	void forTestClassSetsNameToNullIfAnnotationNameIsNull() {
-		List<BeanOverrideHandler> list = BeanOverrideHandler.forTestClass(SampleOneOverride.class);
-		assertThat(list).singleElement().satisfies(handler -> assertThat(handler.getBeanName()).isNull());
+	void setsBeanNameToNullIfAnnotationNameIsNull() {
+		List<BeanOverrideHandler> handlers = BeanOverrideHandler.forTestClass(SampleOneOverride.class);
+		assertThat(handlers).singleElement().extracting(BeanOverrideHandler::getBeanName).isNull();
 	}
 
 	@Test
-	void forTestClassSetsNameToAnnotationName() {
-		List<BeanOverrideHandler> list = BeanOverrideHandler.forTestClass(SampleOneOverrideWithName.class);
-		assertThat(list).singleElement().satisfies(handler -> assertThat(handler.getBeanName()).isEqualTo("anotherBean"));
+	void setsBeanNameToAnnotationName() {
+		List<BeanOverrideHandler> handlers = BeanOverrideHandler.forTestClass(SampleOneOverrideWithName.class);
+		assertThat(handlers).singleElement().extracting(BeanOverrideHandler::getBeanName).isEqualTo("anotherBean");
 	}
 
 	@Test
-	void forTestClassWithMissingMethod() {
+	void failsWithMissingMethod() {
 		assertThatIllegalStateException()
-				.isThrownBy(() ->BeanOverrideHandler.forTestClass(SampleMissingMethod.class))
+				.isThrownBy(() -> BeanOverrideHandler.forTestClass(SampleMissingMethod.class))
 				.withMessage("No static method found named message() in %s with return type %s",
 						SampleMissingMethod.class.getName(), String.class.getName());
 	}
 
 	@Test
 	void isEqualToWithSameInstance() {
-		TestBeanBeanOverrideHandler handler = createBeanOverrideHandler(sampleField("message"), sampleMethod("message"));
+		TestBeanOverrideHandler handler = handlerFor(sampleField("message"), sampleMethod("message"));
 		assertThat(handler).isEqualTo(handler);
 		assertThat(handler).hasSameHashCodeAs(handler);
 	}
 
 	@Test
 	void isEqualToWithSameMetadata() {
-		TestBeanBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("message"), sampleMethod("message"));
-		TestBeanBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("message"), sampleMethod("message"));
+		TestBeanOverrideHandler handler1 = handlerFor(sampleField("message"), sampleMethod("message"));
+		TestBeanOverrideHandler handler2 = handlerFor(sampleField("message"), sampleMethod("message"));
 		assertThat(handler1).isEqualTo(handler2);
 		assertThat(handler1).hasSameHashCodeAs(handler2);
 	}
 
 	@Test
 	void isEqualToWithSameMetadataByNameLookupAndDifferentField() {
-		TestBeanBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("message3"), sampleMethod("message"));
-		TestBeanBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("message4"), sampleMethod("message"));
+		TestBeanOverrideHandler handler1 = handlerFor(sampleField("message3"), sampleMethod("message"));
+		TestBeanOverrideHandler handler2 = handlerFor(sampleField("message4"), sampleMethod("message"));
 		assertThat(handler1).isEqualTo(handler2);
 		assertThat(handler1).hasSameHashCodeAs(handler2);
 	}
 
 	@Test
 	void isNotEqualToWithSameMetadataByTypeLookupAndDifferentField() {
-		TestBeanBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("message"), sampleMethod("message"));
-		TestBeanBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("message2"), sampleMethod("message"));
+		TestBeanOverrideHandler handler1 = handlerFor(sampleField("message"), sampleMethod("message"));
+		TestBeanOverrideHandler handler2 = handlerFor(sampleField("message2"), sampleMethod("message"));
 		assertThat(handler1).isNotEqualTo(handler2);
 	}
 
 	@Test
 	void isNotEqualToWithSameMetadataButDifferentBeanName() {
-		TestBeanBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("message"), sampleMethod("message"));
-		TestBeanBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("message3"), sampleMethod("message"));
+		TestBeanOverrideHandler handler1 = handlerFor(sampleField("message"), sampleMethod("message"));
+		TestBeanOverrideHandler handler2 = handlerFor(sampleField("message3"), sampleMethod("message"));
 		assertThat(handler1).isNotEqualTo(handler2);
 	}
 
 	@Test
 	void isNotEqualToWithSameMetadataButDifferentMethod() {
-		TestBeanBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("message"), sampleMethod("message"));
-		TestBeanBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("message"), sampleMethod("description"));
+		TestBeanOverrideHandler handler1 = handlerFor(sampleField("message"), sampleMethod("message"));
+		TestBeanOverrideHandler handler2 = handlerFor(sampleField("message"), sampleMethod("description"));
 		assertThat(handler1).isNotEqualTo(handler2);
 	}
 
 	@Test
 	void isNotEqualToWithSameMetadataButDifferentAnnotations() {
-		TestBeanBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("message"), sampleMethod("message"));
-		TestBeanBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("message5"), sampleMethod("message"));
+		TestBeanOverrideHandler handler1 = handlerFor(sampleField("message"), sampleMethod("message"));
+		TestBeanOverrideHandler handler2 = handlerFor(sampleField("message5"), sampleMethod("message"));
 		assertThat(handler1).isNotEqualTo(handler2);
 	}
 
-	private Field sampleField(String fieldName) {
+
+	private static Field sampleField(String fieldName) {
 		Field field = ReflectionUtils.findField(Sample.class, fieldName);
 		assertThat(field).isNotNull();
 		return field;
 	}
 
-	private Method sampleMethod(String noArgMethodName) {
+	private static Method sampleMethod(String noArgMethodName) {
 		Method method = ReflectionUtils.findMethod(Sample.class, noArgMethodName);
 		assertThat(method).isNotNull();
 		return method;
 	}
 
-	private TestBeanBeanOverrideHandler createBeanOverrideHandler(Field field, Method overrideMethod) {
+	private static TestBeanOverrideHandler handlerFor(Field field, Method overrideMethod) {
 		TestBean annotation = field.getAnnotation(TestBean.class);
 		String beanName = (StringUtils.hasText(annotation.name()) ? annotation.name() : null);
-		return new TestBeanBeanOverrideHandler(
+		return new TestBeanOverrideHandler(
 				field, ResolvableType.forClass(field.getType()), beanName, BeanOverrideStrategy.REPLACE, overrideMethod);
 	}
 
@@ -137,7 +140,6 @@ static class SampleOneOverride {
 		static String message() {
 			return "OK";
 		}
-
 	}
 
 	static class SampleOneOverrideWithName {
@@ -148,14 +150,12 @@ static class SampleOneOverrideWithName {
 		static String message() {
 			return "OK";
 		}
-
 	}
 
 	static class SampleMissingMethod {
 
 		@TestBean
 		String message;
-
 	}
 
 

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

@@ -172,7 +172,7 @@ void createBeanOverrideHandlerForKnownExplicitMethod() throws Exception {
 		assertThat(overrideAnnotation).isNotNull();
 
 		assertThat(this.processor.createHandler(overrideAnnotation, clazz, field))
-				.isInstanceOf(TestBeanBeanOverrideHandler.class);
+				.isInstanceOf(TestBeanOverrideHandler.class);
 	}
 
 	@Test