root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Remove extra "Bean" from TestBeanBeanOverrideHandler class name 

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

See gh-33702
This commit is contained in:
Sam Brannen 2024-11-01 14:57:30 +01:00
parent 86784b61cc
commit 97f23dca22
5 changed files with 41 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -50,7 +50,8 @@ import org.springframework.test.context.bean.override.BeanOverride;
* 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 @@ public @interface TestBean {
* <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.
*/

8
spring-test/src/main/java/org/springframework/test/context/bean/override/convention/TestBeanBeanOverrideHandler.java → spring-test/src/main/java/org/springframework/test/context/bean/override/convention/TestBeanOverrideHandler.java
View File

@ -29,19 +29,19 @@ import org.springframework.test.context.bean.override.BeanOverrideStrategy;
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 @@ final class TestBeanBeanOverrideHandler extends BeanOverrideHandler {
if (!super.equals(other)) {
return false;
}
TestBeanBeanOverrideHandler that = (TestBeanBeanOverrideHandler) other;
TestBeanOverrideHandler that = (TestBeanOverrideHandler) other;
return Objects.equals(this.factoryMethod, that.factoryMethod);
}

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

@ -42,7 +42,7 @@ import static org.springframework.test.context.bean.override.BeanOverrideStrateg
/**
* {@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 @@ import static org.springframework.test.context.bean.override.BeanOverrideStrateg
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 @@ class TestBeanOverrideProcessor implements BeanOverrideProcessor {
factoryMethod = findTestBeanFactoryMethod(testClass, field.getType(), candidateMethodNames);
}
return new TestBeanBeanOverrideHandler(
return new TestBeanOverrideHandler(
field, ResolvableType.forField(field, testClass), beanName, strategy, factoryMethod);
}

60
spring-test/src/test/java/org/springframework/test/context/bean/override/convention/TestBeanBeanOverrideHandlerTests.java → spring-test/src/test/java/org/springframework/test/context/bean/override/convention/TestBeanOverrideHandlerTests.java
View File

@ -33,99 +33,102 @@ import static org.assertj.core.api.Assertions.assertThat;
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 @@ class TestBeanBeanOverrideHandlerTests {
static String message() {
return "OK";
}
}
static class SampleOneOverrideWithName {
@ -148,14 +150,12 @@ class TestBeanBeanOverrideHandlerTests {
static String message() {
return "OK";
}
}
static class SampleMissingMethod {
@TestBean
String message;
}

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

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