Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rename OverrideMetadata for Bean Overrides

Browse Source 
Prior to this commit, OverrideMetadata was the only public type in the
org.springframework.test.context.bean.override package whose name did
not start with BeanOverride. In addition, an OverrideMetadata component
plays multiple roles in addition to serving as a holder for metadata.

This commit therefore renames OverrideMetadata to BeanOverrideHandler.

In addition, this commit updates the affected documentation and renames
the following related methods in the Bean Override support.

- BeanOverrideHandler: createOverride() -> createOverrideInstance()
- BeanOverrideHandler: track() -> trackOverrideInstance()
- BeanOverrideProcessor: createMetadata() -> createHandler()
- BeanOverrideContextCustomizer: getMetadata() -> getBeanOverrideHandlers()
- BeanOverrideRegistrar: registerNameForMetadata() -> registerBeanOverrideHandler()
- BeanOverrideRegistrar: markWrapEarly() -> registerWrappingBeanOverrideHandler()

Closes gh-33702
This commit is contained in:
Sam Brannen
2024-10-16 16:32:38 +02:00
parent ab4fe5a29c
commit c0c78bd67e
28 changed files with 674 additions and 663 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -354,8 +354,8 @@ class BeanOverrideBeanFactoryPostProcessorTests {
private AnnotationConfigApplicationContext createContext(Class<?> testClass) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
Set<OverrideMetadata> metadata = new LinkedHashSet<>(OverrideMetadata.forTestClass(testClass));
new BeanOverrideContextCustomizer(metadata).customizeContext(context, mock(MergedContextConfiguration.class));
Set<BeanOverrideHandler> handlers = new LinkedHashSet<>(BeanOverrideHandler.forTestClass(testClass));
new BeanOverrideContextCustomizer(handlers).customizeContext(context, mock(MergedContextConfiguration.class));
return context;
}

35
spring-test/src/test/java/org/springframework/test/context/bean/override/BeanOverrideContextCustomizerFactoryTests.java
View File

@@ -23,9 +23,7 @@ import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.springframework.lang.Nullable;
import org.springframework.test.context.bean.override.BeanOverrideContextCustomizerFactoryTests.Test2.Green;
import org.springframework.test.context.bean.override.BeanOverrideContextCustomizerFactoryTests.Test2.Orange;
import org.springframework.test.context.bean.override.DummyBean.DummyBeanOverrideProcessor.DummyOverrideMetadata;
import org.springframework.test.context.bean.override.DummyBean.DummyBeanOverrideProcessor.DummyBeanOverrideHandler;
import static org.assertj.core.api.Assertions.assertThat;
@@ -47,37 +45,37 @@ class BeanOverrideContextCustomizerFactoryTests {
void createContextCustomizerWhenTestHasSingleBeanOverride() {
BeanOverrideContextCustomizer customizer = createContextCustomizer(Test1.class);
assertThat(customizer).isNotNull();
assertThat(customizer.getMetadata()).singleElement().satisfies(dummyMetadata(null, String.class));
assertThat(customizer.getBeanOverrideHandlers()).singleElement().satisfies(dummyHandler(null, String.class));
}
@Test
void createContextCustomizerWhenNestedTestHasSingleBeanOverrideInParent() {
BeanOverrideContextCustomizer customizer = createContextCustomizer(Orange.class);
BeanOverrideContextCustomizer customizer = createContextCustomizer(Test2.Orange.class);
assertThat(customizer).isNotNull();
assertThat(customizer.getMetadata()).singleElement().satisfies(dummyMetadata(null, String.class));
assertThat(customizer.getBeanOverrideHandlers()).singleElement().satisfies(dummyHandler(null, String.class));
}
@Test
void createContextCustomizerWhenNestedTestHasBeanOverrideAsWellAsTheParent() {
BeanOverrideContextCustomizer customizer = createContextCustomizer(Green.class);
BeanOverrideContextCustomizer customizer = createContextCustomizer(Test2.Green.class);
assertThat(customizer).isNotNull();
assertThat(customizer.getMetadata())
.anySatisfy(dummyMetadata(null, String.class))
.anySatisfy(dummyMetadata("counterBean", Integer.class))
assertThat(customizer.getBeanOverrideHandlers())
.anySatisfy(dummyHandler(null, String.class))
.anySatisfy(dummyHandler("counterBean", Integer.class))
.hasSize(2);
}
private Consumer<OverrideMetadata> dummyMetadata(@Nullable String beanName, Class<?> beanType) {
return dummyMetadata(beanName, beanType, BeanOverrideStrategy.REPLACE);
private Consumer<BeanOverrideHandler> dummyHandler(@Nullable String beanName, Class<?> beanType) {
return dummyHandler(beanName, beanType, BeanOverrideStrategy.REPLACE);
}
private Consumer<OverrideMetadata> dummyMetadata(@Nullable String beanName, Class<?> beanType, BeanOverrideStrategy strategy) {
return metadata -> {
assertThat(metadata).isExactlyInstanceOf(DummyOverrideMetadata.class);
assertThat(metadata.getBeanName()).isEqualTo(beanName);
assertThat(metadata.getBeanType().toClass()).isEqualTo(beanType);
assertThat(metadata.getStrategy()).isEqualTo(strategy);
private Consumer<BeanOverrideHandler> dummyHandler(@Nullable String beanName, Class<?> beanType, BeanOverrideStrategy strategy) {
return handler -> {
assertThat(handler).isExactlyInstanceOf(DummyBeanOverrideHandler.class);
assertThat(handler.getBeanName()).isEqualTo(beanName);
assertThat(handler.getBeanType().toClass()).isEqualTo(beanType);
assertThat(handler.getStrategy()).isEqualTo(strategy);
};
}
@@ -100,7 +98,6 @@ class BeanOverrideContextCustomizerFactoryTests {
@Nested
class Orange {
}
@Nested

26
spring-test/src/test/java/org/springframework/test/context/bean/override/BeanOverrideContextCustomizerTests.java
View File

@@ -38,8 +38,8 @@ class BeanOverrideContextCustomizerTests {
@Test
void customizerIsEqualWithIdenticalMetadata() {
BeanOverrideContextCustomizer customizer = createCustomizer(new DummyOverrideMetadata("key"));
BeanOverrideContextCustomizer customizer2 = createCustomizer(new DummyOverrideMetadata("key"));
BeanOverrideContextCustomizer customizer = createCustomizer(new DummyBeanOverrideHandler("key"));
BeanOverrideContextCustomizer customizer2 = createCustomizer(new DummyBeanOverrideHandler("key"));
assertThat(customizer).isEqualTo(customizer2);
assertThat(customizer).hasSameHashCodeAs(customizer2);
}
@@ -47,37 +47,37 @@ class BeanOverrideContextCustomizerTests {
@Test
void customizerIsEqualWithIdenticalMetadataInDifferentOrder() {
BeanOverrideContextCustomizer customizer = createCustomizer(
new DummyOverrideMetadata("key1"), new DummyOverrideMetadata("key2"));
new DummyBeanOverrideHandler("key1"), new DummyBeanOverrideHandler("key2"));
BeanOverrideContextCustomizer customizer2 = createCustomizer(
new DummyOverrideMetadata("key2"), new DummyOverrideMetadata("key1"));
new DummyBeanOverrideHandler("key2"), new DummyBeanOverrideHandler("key1"));
assertThat(customizer).isEqualTo(customizer2);
assertThat(customizer).hasSameHashCodeAs(customizer2);
}
@Test
void customizerIsNotEqualWithDifferentMetadata() {
BeanOverrideContextCustomizer customizer = createCustomizer(new DummyOverrideMetadata("key"));
BeanOverrideContextCustomizer customizer = createCustomizer(new DummyBeanOverrideHandler("key"));
BeanOverrideContextCustomizer customizer2 = createCustomizer(
new DummyOverrideMetadata("key"), new DummyOverrideMetadata("another"));
new DummyBeanOverrideHandler("key"), new DummyBeanOverrideHandler("another"));
assertThat(customizer).isNotEqualTo(customizer2);
}
private BeanOverrideContextCustomizer createCustomizer(OverrideMetadata... metadata) {
return new BeanOverrideContextCustomizer(new LinkedHashSet<>(Arrays.asList(metadata)));
private BeanOverrideContextCustomizer createCustomizer(BeanOverrideHandler... handlers) {
return new BeanOverrideContextCustomizer(new LinkedHashSet<>(Arrays.asList(handlers)));
}
private static class DummyOverrideMetadata extends OverrideMetadata {
private static class DummyBeanOverrideHandler extends BeanOverrideHandler {
private final String key;
public DummyOverrideMetadata(String key) {
super(ReflectionUtils.findField(DummyOverrideMetadata.class, "key"),
public DummyBeanOverrideHandler(String key) {
super(ReflectionUtils.findField(DummyBeanOverrideHandler.class, "key"),
ResolvableType.forClass(Object.class), null, BeanOverrideStrategy.REPLACE);
this.key = key;
}
@Override
protected Object createOverride(String beanName, BeanDefinition existingBeanDefinition,
protected Object createOverrideInstance(String beanName, BeanDefinition existingBeanDefinition,
Object existingBeanInstance) {
return existingBeanInstance;
}
@@ -90,7 +90,7 @@ class BeanOverrideContextCustomizerTests {
if (o == null || getClass() != o.getClass()) {
return false;
}
DummyOverrideMetadata that = (DummyOverrideMetadata) o;
DummyBeanOverrideHandler that = (DummyBeanOverrideHandler) o;
return Objects.equals(this.key, that.key);
}

286
spring-test/src/test/java/org/springframework/test/context/bean/override/BeanOverrideHandlerTests.java Normal file
View File

@@ -0,0 +1,286 @@
/*
* 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;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.function.Consumer;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.lang.Nullable;
import org.springframework.test.context.bean.override.DummyBean.DummyBeanOverrideProcessor.DummyBeanOverrideHandler;
import org.springframework.test.context.bean.override.example.CustomQualifier;
import org.springframework.test.context.bean.override.example.ExampleService;
import org.springframework.util.ReflectionUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.assertj.core.api.SoftAssertions.assertSoftly;
/**
* Tests for {@link BeanOverrideHandler}.
*
* @author Simon Baslé
* @author Stephane Nicoll
* @author Sam Brannen
* @since 6.2
*/
class BeanOverrideHandlerTests {
@Test
void forTestClassWithSingleField() {
List<BeanOverrideHandler> handlers = BeanOverrideHandler.forTestClass(SingleAnnotation.class);
assertThat(handlers).singleElement().satisfies(hasBeanOverrideHandler(
field(SingleAnnotation.class, "message"), String.class, null));
}
@Test
void forTestClassWithMultipleFields() {
List<BeanOverrideHandler> handlers = BeanOverrideHandler.forTestClass(MultipleAnnotations.class);
assertThat(handlers).hasSize(2)
.anySatisfy(hasBeanOverrideHandler(
field(MultipleAnnotations.class, "message"), String.class, null))
.anySatisfy(hasBeanOverrideHandler(
field(MultipleAnnotations.class, "counter"), Integer.class, null));
}
@Test
void forTestClassWithMultipleFieldsWithIdenticalMetadata() {
List<BeanOverrideHandler> handlers = BeanOverrideHandler.forTestClass(MultipleAnnotationsDuplicate.class);
assertThat(handlers).hasSize(2)
.anySatisfy(hasBeanOverrideHandler(
field(MultipleAnnotationsDuplicate.class, "message1"), String.class, "messageBean"))
.anySatisfy(hasBeanOverrideHandler(
field(MultipleAnnotationsDuplicate.class, "message2"), String.class, "messageBean"));
assertThat(new HashSet<>(handlers)).hasSize(1);
}
@Test
void forTestClassWithCompetingBeanOverrideAnnotationsOnSameField() {
Field faultyField = field(MultipleAnnotationsOnSameField.class, "message");
assertThatIllegalStateException()
.isThrownBy(() -> BeanOverrideHandler.forTestClass(MultipleAnnotationsOnSameField.class))
.withMessageStartingWith("Multiple @BeanOverride annotations found")
.withMessageContaining(faultyField.toString());
}
@Test
void getBeanNameIsNullByDefault() {
BeanOverrideHandler handler = createBeanOverrideHandler(field(ConfigA.class, "noQualifier"));
assertThat(handler.getBeanName()).isNull();
}
@Test
void isEqualToWithSameInstance() {
BeanOverrideHandler handler = createBeanOverrideHandler(field(ConfigA.class, "noQualifier"));
assertThat(handler).isEqualTo(handler);
assertThat(handler).hasSameHashCodeAs(handler);
}
@Test
void isEqualToWithSameMetadata() {
BeanOverrideHandler handler1 = createBeanOverrideHandler(field(ConfigA.class, "noQualifier"));
BeanOverrideHandler handler2 = createBeanOverrideHandler(field(ConfigA.class, "noQualifier"));
assertThat(handler1).isEqualTo(handler2);
assertThat(handler1).hasSameHashCodeAs(handler2);
}
@Test
void isEqualToWithSameMetadataAndBeanNames() {
BeanOverrideHandler handler1 = createBeanOverrideHandler(field(ConfigA.class, "noQualifier"), "testBean");
BeanOverrideHandler handler2 = createBeanOverrideHandler(field(ConfigA.class, "noQualifier"), "testBean");
assertThat(handler1).isEqualTo(handler2);
assertThat(handler1).hasSameHashCodeAs(handler2);
}
@Test
void isNotEqualToWithSameMetadataAndDifferentBeaName() {
BeanOverrideHandler handler1 = createBeanOverrideHandler(field(ConfigA.class, "noQualifier"), "testBean");
BeanOverrideHandler handler2 = createBeanOverrideHandler(field(ConfigA.class, "noQualifier"), "testBean2");
assertThat(handler1).isNotEqualTo(handler2);
}
@Test
void isEqualToWithSameMetadataButDifferentFields() {
BeanOverrideHandler handler1 = createBeanOverrideHandler(field(ConfigA.class, "noQualifier"));
BeanOverrideHandler handler2 = createBeanOverrideHandler(field(ConfigB.class, "noQualifier"));
assertThat(handler1).isEqualTo(handler2);
assertThat(handler1).hasSameHashCodeAs(handler2);
}
@Test
void isEqualToWithByNameLookupAndDifferentFieldNames() {
BeanOverrideHandler handler1 = createBeanOverrideHandler(field(ConfigA.class, "noQualifier"), "beanToOverride");
BeanOverrideHandler handler2 = createBeanOverrideHandler(field(ConfigB.class, "example"), "beanToOverride");
assertThat(handler1).isEqualTo(handler2);
assertThat(handler1).hasSameHashCodeAs(handler2);
}
@Test
void isEqualToWithSameMetadataAndSameQualifierValues() {
BeanOverrideHandler handler1 = createBeanOverrideHandler(field(ConfigA.class, "directQualifier"));
BeanOverrideHandler handler2 = createBeanOverrideHandler(field(ConfigB.class, "directQualifier"));
assertThat(handler1).isEqualTo(handler2);
assertThat(handler1).hasSameHashCodeAs(handler2);
}
@Test
void isEqualToWithSameMetadataAndSameQualifierValuesButWithAnnotationsDeclaredInDifferentOrder() {
Field field1 = field(ConfigA.class, "qualifiedDummyBean");
Field field2 = field(ConfigB.class, "qualifiedDummyBean");
// Prerequisite
assertThat(Arrays.equals(field1.getAnnotations(), field2.getAnnotations())).isFalse();
BeanOverrideHandler handler1 = createBeanOverrideHandler(field1);
BeanOverrideHandler handler2 = createBeanOverrideHandler(field2);
assertThat(handler1).isEqualTo(handler2);
assertThat(handler1).hasSameHashCodeAs(handler2);
}
@Test
void isNotEqualToWithSameMetadataAndDifferentQualifierValues() {
BeanOverrideHandler handler1 = createBeanOverrideHandler(field(ConfigA.class, "directQualifier"));
BeanOverrideHandler handler2 = createBeanOverrideHandler(field(ConfigA.class, "differentDirectQualifier"));
assertThat(handler1).isNotEqualTo(handler2);
}
@Test
void isNotEqualToWithSameMetadataAndDifferentQualifiers() {
BeanOverrideHandler handler1 = createBeanOverrideHandler(field(ConfigA.class, "directQualifier"));
BeanOverrideHandler handler2 = createBeanOverrideHandler(field(ConfigA.class, "customQualifier"));
assertThat(handler1).isNotEqualTo(handler2);
}
@Test
void isNotEqualToWithByTypeLookupAndDifferentFieldNames() {
BeanOverrideHandler handler1 = createBeanOverrideHandler(field(ConfigA.class, "noQualifier"));
BeanOverrideHandler handler2 = createBeanOverrideHandler(field(ConfigB.class, "example"));
assertThat(handler1).isNotEqualTo(handler2);
}
private static BeanOverrideHandler createBeanOverrideHandler(Field field) {
return createBeanOverrideHandler(field, null);
}
private static BeanOverrideHandler createBeanOverrideHandler(Field field, @Nullable String name) {
return new DummyBeanOverrideHandler(field, field.getType(), name, BeanOverrideStrategy.REPLACE);
}
private static Field field(Class<?> target, String fieldName) {
Field field = ReflectionUtils.findField(target, fieldName);
assertThat(field).isNotNull();
return field;
}
private static Consumer<BeanOverrideHandler> hasBeanOverrideHandler(Field field, Class<?> beanType, @Nullable String beanName) {
return hasBeanOverrideHandler(field, beanType, BeanOverrideStrategy.REPLACE, beanName);
}
private static Consumer<BeanOverrideHandler> hasBeanOverrideHandler(Field field, Class<?> beanType, BeanOverrideStrategy strategy,
@Nullable String beanName) {
return handler -> assertSoftly(softly -> {
softly.assertThat(handler.getField()).as("field").isEqualTo(field);
softly.assertThat(handler.getBeanType().toClass()).as("type").isEqualTo(beanType);
softly.assertThat(handler.getBeanName()).as("name").isEqualTo(beanName);
softly.assertThat(handler.getStrategy()).as("strategy").isEqualTo(strategy);
});
}
static class SingleAnnotation {
@DummyBean
String message;
}
static class MultipleAnnotations {
@DummyBean
String message;
@DummyBean
Integer counter;
}
static class MultipleAnnotationsDuplicate {
@DummyBean(beanName = "messageBean")
String message1;
@DummyBean(beanName = "messageBean")
String message2;
}
static class MultipleAnnotationsOnSameField {
@MetaDummyBean()
@DummyBean
String message;
static String foo() {
return "foo";
}
}
static class ConfigA {
ExampleService noQualifier;
@Qualifier("test")
ExampleService directQualifier;
@Qualifier("different")
ExampleService differentDirectQualifier;
@CustomQualifier
ExampleService customQualifier;
@DummyBean
@Qualifier("test")
ExampleService qualifiedDummyBean;
}
static class ConfigB {
ExampleService noQualifier;
ExampleService example;
@Qualifier("test")
ExampleService directQualifier;
@Qualifier("test")
@DummyBean
ExampleService qualifiedDummyBean;
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@DummyBean
@interface MetaDummyBean {}
}

12
spring-test/src/test/java/org/springframework/test/context/bean/override/DummyBean.java
View File

@@ -50,25 +50,25 @@ import org.springframework.util.StringUtils;
class DummyBeanOverrideProcessor implements BeanOverrideProcessor {
@Override
public OverrideMetadata createMetadata(Annotation annotation, Class<?> testClass, Field field) {
public BeanOverrideHandler createHandler(Annotation annotation, Class<?> testClass, Field field) {
DummyBean dummyBean = (DummyBean) annotation;
String beanName = (StringUtils.hasText(dummyBean.beanName()) ? dummyBean.beanName() : null);
return new DummyBeanOverrideProcessor.DummyOverrideMetadata(field, field.getType(), beanName,
return new DummyBeanOverrideProcessor.DummyBeanOverrideHandler(field, field.getType(), beanName,
dummyBean.strategy());
}
// Bare bone, "dummy", implementation that should not override anything
// else than createOverride.
static class DummyOverrideMetadata extends OverrideMetadata {
// other than createOverrideInstance().
static class DummyBeanOverrideHandler extends BeanOverrideHandler {
DummyOverrideMetadata(Field field, Class<?> typeToOverride, @Nullable String beanName,
DummyBeanOverrideHandler(Field field, Class<?> typeToOverride, @Nullable String beanName,
BeanOverrideStrategy strategy) {
super(field, ResolvableType.forClass(typeToOverride), beanName, strategy);
}
@Override
protected Object createOverride(String beanName, @Nullable BeanDefinition existingBeanDefinition,
protected Object createOverrideInstance(String beanName, @Nullable BeanDefinition existingBeanDefinition,
@Nullable Object existingBeanInstance) {
Class<?> beanType = getField().getType();

285
spring-test/src/test/java/org/springframework/test/context/bean/override/OverrideMetadataTests.java
View File

@@ -1,285 +0,0 @@
/*
* 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;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.function.Consumer;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.lang.Nullable;
import org.springframework.test.context.bean.override.DummyBean.DummyBeanOverrideProcessor.DummyOverrideMetadata;
import org.springframework.test.context.bean.override.example.CustomQualifier;
import org.springframework.test.context.bean.override.example.ExampleService;
import org.springframework.util.ReflectionUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
/**
* Tests for {@link OverrideMetadata}.
*
* @author Simon Baslé
* @author Stephane Nicoll
* @author Sam Brannen
* @since 6.2
*/
class OverrideMetadataTests {
@Test
void forTestClassWithSingleField() {
List<OverrideMetadata> overrideMetadata = OverrideMetadata.forTestClass(SingleAnnotation.class);
assertThat(overrideMetadata).singleElement().satisfies(hasOverrideMetadata(
field(SingleAnnotation.class, "message"), String.class, null));
}
@Test
void forTestClassWithMultipleFields() {
List<OverrideMetadata> overrideMetadata = OverrideMetadata.forTestClass(MultipleAnnotations.class);
assertThat(overrideMetadata).hasSize(2)
.anySatisfy(hasOverrideMetadata(
field(MultipleAnnotations.class, "message"), String.class, null))
.anySatisfy(hasOverrideMetadata(
field(MultipleAnnotations.class, "counter"), Integer.class, null));
}
@Test
void forTestClassWithMultipleFieldsWithIdenticalMetadata() {
List<OverrideMetadata> overrideMetadata = OverrideMetadata.forTestClass(MultipleAnnotationsDuplicate.class);
assertThat(overrideMetadata).hasSize(2)
.anySatisfy(hasOverrideMetadata(
field(MultipleAnnotationsDuplicate.class, "message1"), String.class, "messageBean"))
.anySatisfy(hasOverrideMetadata(
field(MultipleAnnotationsDuplicate.class, "message2"), String.class, "messageBean"));
assertThat(new HashSet<>(overrideMetadata)).hasSize(1);
}
@Test
void forTestClassWithCompetingBeanOverrideAnnotationsOnSameField() {
Field faultyField = field(MultipleAnnotationsOnSameField.class, "message");
assertThatIllegalStateException()
.isThrownBy(() -> OverrideMetadata.forTestClass(MultipleAnnotationsOnSameField.class))
.withMessageStartingWith("Multiple @BeanOverride annotations found")
.withMessageContaining(faultyField.toString());
}
@Test
void getBeanNameIsNullByDefault() {
OverrideMetadata metadata = createMetadata(field(ConfigA.class, "noQualifier"));
assertThat(metadata.getBeanName()).isNull();
}
@Test
void isEqualToWithSameInstance() {
OverrideMetadata metadata = createMetadata(field(ConfigA.class, "noQualifier"));
assertThat(metadata).isEqualTo(metadata);
assertThat(metadata).hasSameHashCodeAs(metadata);
}
@Test
void isEqualToWithSameMetadata() {
OverrideMetadata metadata = createMetadata(field(ConfigA.class, "noQualifier"));
OverrideMetadata metadata2 = createMetadata(field(ConfigA.class, "noQualifier"));
assertThat(metadata).isEqualTo(metadata2);
assertThat(metadata).hasSameHashCodeAs(metadata2);
}
@Test
void isEqualToWithSameMetadataAndBeanNames() {
OverrideMetadata metadata = createMetadata(field(ConfigA.class, "noQualifier"), "testBean");
OverrideMetadata metadata2 = createMetadata(field(ConfigA.class, "noQualifier"), "testBean");
assertThat(metadata).isEqualTo(metadata2);
assertThat(metadata).hasSameHashCodeAs(metadata2);
}
@Test
void isNotEqualToWithSameMetadataAndDifferentBeaName() {
OverrideMetadata metadata = createMetadata(field(ConfigA.class, "noQualifier"), "testBean");
OverrideMetadata metadata2 = createMetadata(field(ConfigA.class, "noQualifier"), "testBean2");
assertThat(metadata).isNotEqualTo(metadata2);
}
@Test
void isEqualToWithSameMetadataButDifferentFields() {
OverrideMetadata metadata = createMetadata(field(ConfigA.class, "noQualifier"));
OverrideMetadata metadata2 = createMetadata(field(ConfigB.class, "noQualifier"));
assertThat(metadata).isEqualTo(metadata2);
assertThat(metadata).hasSameHashCodeAs(metadata2);
}
@Test
void isEqualToWithByNameLookupAndDifferentFieldNames() {
OverrideMetadata metadata = createMetadata(field(ConfigA.class, "noQualifier"), "beanToOverride");
OverrideMetadata metadata2 = createMetadata(field(ConfigB.class, "example"), "beanToOverride");
assertThat(metadata).isEqualTo(metadata2);
assertThat(metadata).hasSameHashCodeAs(metadata2);
}
@Test
void isEqualToWithSameMetadataAndSameQualifierValues() {
OverrideMetadata metadata = createMetadata(field(ConfigA.class, "directQualifier"));
OverrideMetadata metadata2 = createMetadata(field(ConfigB.class, "directQualifier"));
assertThat(metadata).isEqualTo(metadata2);
assertThat(metadata).hasSameHashCodeAs(metadata2);
}
@Test
void isEqualToWithSameMetadataAndSameQualifierValuesButWithAnnotationsDeclaredInDifferentOrder() {
Field field1 = field(ConfigA.class, "qualifiedDummyBean");
Field field2 = field(ConfigB.class, "qualifiedDummyBean");
// Prerequisite
assertThat(Arrays.equals(field1.getAnnotations(), field2.getAnnotations())).isFalse();
OverrideMetadata metadata1 = createMetadata(field1);
OverrideMetadata metadata2 = createMetadata(field2);
assertThat(metadata1).isEqualTo(metadata2);
assertThat(metadata1).hasSameHashCodeAs(metadata2);
}
@Test
void isNotEqualToWithSameMetadataAndDifferentQualifierValues() {
OverrideMetadata metadata = createMetadata(field(ConfigA.class, "directQualifier"));
OverrideMetadata metadata2 = createMetadata(field(ConfigA.class, "differentDirectQualifier"));
assertThat(metadata).isNotEqualTo(metadata2);
}
@Test
void isNotEqualToWithSameMetadataAndDifferentQualifiers() {
OverrideMetadata metadata = createMetadata(field(ConfigA.class, "directQualifier"));
OverrideMetadata metadata2 = createMetadata(field(ConfigA.class, "customQualifier"));
assertThat(metadata).isNotEqualTo(metadata2);
}
@Test
void isNotEqualToWithByTypeLookupAndDifferentFieldNames() {
OverrideMetadata metadata = createMetadata(field(ConfigA.class, "noQualifier"));
OverrideMetadata metadata2 = createMetadata(field(ConfigB.class, "example"));
assertThat(metadata).isNotEqualTo(metadata2);
}
private static OverrideMetadata createMetadata(Field field) {
return createMetadata(field, null);
}
private static OverrideMetadata createMetadata(Field field, @Nullable String name) {
return new DummyOverrideMetadata(field, field.getType(), name, BeanOverrideStrategy.REPLACE);
}
private static Field field(Class<?> target, String fieldName) {
Field field = ReflectionUtils.findField(target, fieldName);
assertThat(field).isNotNull();
return field;
}
private static Consumer<OverrideMetadata> hasOverrideMetadata(Field field, Class<?> beanType, @Nullable String beanName) {
return hasOverrideMetadata(field, beanType, BeanOverrideStrategy.REPLACE, beanName);
}
private static Consumer<OverrideMetadata> hasOverrideMetadata(Field field, Class<?> beanType, BeanOverrideStrategy strategy,
@Nullable String beanName) {
return metadata -> {
assertThat(metadata.getField()).isEqualTo(field);
assertThat(metadata.getBeanType().toClass()).isEqualTo(beanType);
assertThat(metadata.getStrategy()).isEqualTo(strategy);
assertThat(metadata.getBeanName()).isEqualTo(beanName);
};
}
static class SingleAnnotation {
@DummyBean
String message;
}
static class MultipleAnnotations {
@DummyBean
String message;
@DummyBean
Integer counter;
}
static class MultipleAnnotationsDuplicate {
@DummyBean(beanName = "messageBean")
String message1;
@DummyBean(beanName = "messageBean")
String message2;
}
static class MultipleAnnotationsOnSameField {
@MetaDummyBean()
@DummyBean
String message;
static String foo() {
return "foo";
}
}
static class ConfigA {
ExampleService noQualifier;
@Qualifier("test")
ExampleService directQualifier;
@Qualifier("different")
ExampleService differentDirectQualifier;
@CustomQualifier
ExampleService customQualifier;
@DummyBean
@Qualifier("test")
ExampleService qualifiedDummyBean;
}
static class ConfigB {
ExampleService noQualifier;
ExampleService example;
@Qualifier("test")
ExampleService directQualifier;
@Qualifier("test")
@DummyBean
ExampleService qualifiedDummyBean;
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@DummyBean
@interface MetaDummyBean {}
}

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

@@ -24,8 +24,8 @@ import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.core.ResolvableType;
import org.springframework.test.context.bean.override.BeanOverrideHandler;
import org.springframework.test.context.bean.override.BeanOverrideStrategy;
import org.springframework.test.context.bean.override.OverrideMetadata;
import org.springframework.util.ReflectionUtils;
import org.springframework.util.StringUtils;
@@ -33,81 +33,81 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
/**
* Tests for {@link TestBeanOverrideMetadata}.
* Tests for {@link TestBeanBeanOverrideHandler}.
*
* @author Stephane Nicoll
*/
class TestBeanOverrideMetadataTests {
class TestBeanBeanOverrideHandlerTests {
@Test
void forTestClassSetsNameToNullIfAnnotationNameIsNull() {
List<OverrideMetadata> list = OverrideMetadata.forTestClass(SampleOneOverride.class);
assertThat(list).singleElement().satisfies(metadata -> assertThat(metadata.getBeanName()).isNull());
List<BeanOverrideHandler> list = BeanOverrideHandler.forTestClass(SampleOneOverride.class);
assertThat(list).singleElement().satisfies(handler -> assertThat(handler.getBeanName()).isNull());
}
@Test
void forTestClassSetsNameToAnnotationName() {
List<OverrideMetadata> list = OverrideMetadata.forTestClass(SampleOneOverrideWithName.class);
assertThat(list).singleElement().satisfies(metadata -> assertThat(metadata.getBeanName()).isEqualTo("anotherBean"));
List<BeanOverrideHandler> list = BeanOverrideHandler.forTestClass(SampleOneOverrideWithName.class);
assertThat(list).singleElement().satisfies(handler -> assertThat(handler.getBeanName()).isEqualTo("anotherBean"));
}
@Test
void forTestClassWithMissingMethod() {
assertThatIllegalStateException()
.isThrownBy(() ->OverrideMetadata.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() {
TestBeanOverrideMetadata metadata = createMetadata(sampleField("message"), sampleMethod("message"));
assertThat(metadata).isEqualTo(metadata);
assertThat(metadata).hasSameHashCodeAs(metadata);
TestBeanBeanOverrideHandler handler = createBeanOverrideHandler(sampleField("message"), sampleMethod("message"));
assertThat(handler).isEqualTo(handler);
assertThat(handler).hasSameHashCodeAs(handler);
}
@Test
void isEqualToWithSameMetadata() {
TestBeanOverrideMetadata metadata1 = createMetadata(sampleField("message"), sampleMethod("message"));
TestBeanOverrideMetadata metadata2 = createMetadata(sampleField("message"), sampleMethod("message"));
assertThat(metadata1).isEqualTo(metadata2);
assertThat(metadata1).hasSameHashCodeAs(metadata2);
TestBeanBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("message"), sampleMethod("message"));
TestBeanBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("message"), sampleMethod("message"));
assertThat(handler1).isEqualTo(handler2);
assertThat(handler1).hasSameHashCodeAs(handler2);
}
@Test
void isEqualToWithSameMetadataByNameLookupAndDifferentField() {
TestBeanOverrideMetadata metadata1 = createMetadata(sampleField("message3"), sampleMethod("message"));
TestBeanOverrideMetadata metadata2 = createMetadata(sampleField("message4"), sampleMethod("message"));
assertThat(metadata1).isEqualTo(metadata2);
assertThat(metadata1).hasSameHashCodeAs(metadata2);
TestBeanBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("message3"), sampleMethod("message"));
TestBeanBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("message4"), sampleMethod("message"));
assertThat(handler1).isEqualTo(handler2);
assertThat(handler1).hasSameHashCodeAs(handler2);
}
@Test
void isNotEqualToWithSameMetadataByTypeLookupAndDifferentField() {
TestBeanOverrideMetadata metadata1 = createMetadata(sampleField("message"), sampleMethod("message"));
TestBeanOverrideMetadata metadata2 = createMetadata(sampleField("message2"), sampleMethod("message"));
assertThat(metadata1).isNotEqualTo(metadata2);
TestBeanBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("message"), sampleMethod("message"));
TestBeanBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("message2"), sampleMethod("message"));
assertThat(handler1).isNotEqualTo(handler2);
}
@Test
void isNotEqualToWithSameMetadataButDifferentBeanName() {
TestBeanOverrideMetadata metadata1 = createMetadata(sampleField("message"), sampleMethod("message"));
TestBeanOverrideMetadata metadata2 = createMetadata(sampleField("message3"), sampleMethod("message"));
assertThat(metadata1).isNotEqualTo(metadata2);
TestBeanBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("message"), sampleMethod("message"));
TestBeanBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("message3"), sampleMethod("message"));
assertThat(handler1).isNotEqualTo(handler2);
}
@Test
void isNotEqualToWithSameMetadataButDifferentMethod() {
TestBeanOverrideMetadata metadata1 = createMetadata(sampleField("message"), sampleMethod("message"));
TestBeanOverrideMetadata metadata2 = createMetadata(sampleField("message"), sampleMethod("description"));
assertThat(metadata1).isNotEqualTo(metadata2);
TestBeanBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("message"), sampleMethod("message"));
TestBeanBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("message"), sampleMethod("description"));
assertThat(handler1).isNotEqualTo(handler2);
}
@Test
void isNotEqualToWithSameMetadataButDifferentAnnotations() {
TestBeanOverrideMetadata metadata1 = createMetadata(sampleField("message"), sampleMethod("message"));
TestBeanOverrideMetadata metadata2 = createMetadata(sampleField("message5"), sampleMethod("message"));
assertThat(metadata1).isNotEqualTo(metadata2);
TestBeanBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("message"), sampleMethod("message"));
TestBeanBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("message5"), sampleMethod("message"));
assertThat(handler1).isNotEqualTo(handler2);
}
private Field sampleField(String fieldName) {
@@ -122,10 +122,10 @@ class TestBeanOverrideMetadataTests {
return method;
}
private TestBeanOverrideMetadata createMetadata(Field field, Method overrideMethod) {
private TestBeanBeanOverrideHandler createBeanOverrideHandler(Field field, Method overrideMethod) {
TestBean annotation = field.getAnnotation(TestBean.class);
String beanName = (StringUtils.hasText(annotation.name()) ? annotation.name() : null);
return new TestBeanOverrideMetadata(
return new TestBeanBeanOverrideHandler(
field, ResolvableType.forClass(field.getType()), beanName, BeanOverrideStrategy.REPLACE, overrideMethod);
}

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

@@ -151,7 +151,7 @@ class TestBeanOverrideProcessorTests {
}
@Test
void createMetaDataForUnknownExplicitMethod() throws Exception {
void createBeanOverrideHandlerForUnknownExplicitMethod() throws Exception {
Class<?> clazz = ExplicitMethodNameTestCase.class;
Class<?> returnType = ExampleService.class;
Field field = clazz.getField("a");
@@ -159,24 +159,24 @@ class TestBeanOverrideProcessorTests {
assertThat(overrideAnnotation).isNotNull();
assertThatIllegalStateException()
.isThrownBy(() -> this.processor.createMetadata(overrideAnnotation, clazz, field))
.isThrownBy(() -> this.processor.createHandler(overrideAnnotation, clazz, field))
.withMessage("No static method found named explicit1() in %s with return type %s",
clazz.getName(), returnType.getName());
}
@Test
void createMetaDataForKnownExplicitMethod() throws Exception {
void createBeanOverrideHandlerForKnownExplicitMethod() throws Exception {
Class<?> clazz = ExplicitMethodNameTestCase.class;
Field field = clazz.getField("b");
TestBean overrideAnnotation = field.getAnnotation(TestBean.class);
assertThat(overrideAnnotation).isNotNull();
assertThat(this.processor.createMetadata(overrideAnnotation, clazz, field))
.isInstanceOf(TestBeanOverrideMetadata.class);
assertThat(this.processor.createHandler(overrideAnnotation, clazz, field))
.isInstanceOf(TestBeanBeanOverrideHandler.class);
}
@Test
void createMetaDataForConventionBasedFactoryMethod() throws Exception {
void createBeanOverrideHandlerForConventionBasedFactoryMethod() throws Exception {
Class<?> returnType = ExampleService.class;
Class<?> clazz = MethodConventionTestCase.class;
Field field = clazz.getField("field");
@@ -184,19 +184,19 @@ class TestBeanOverrideProcessorTests {
assertThat(overrideAnnotation).isNotNull();
assertThatIllegalStateException()
.isThrownBy(() -> this.processor.createMetadata(overrideAnnotation, clazz, field))
.isThrownBy(() -> this.processor.createHandler(overrideAnnotation, clazz, field))
.withMessage("No static method found named field() or someField() in %s with return type %s",
clazz.getName(), returnType.getName());
}
@Test
void failToCreateMetadataForOtherAnnotation() throws NoSuchFieldException {
void failToCreateBeanOverrideHandlerForOtherAnnotation() throws Exception {
Class<?> clazz = MethodConventionTestCase.class;
Field field = clazz.getField("field");
NonNull badAnnotation = AnnotationUtils.synthesizeAnnotation(NonNull.class);
assertThatIllegalStateException()
.isThrownBy(() -> this.processor.createMetadata(badAnnotation, clazz, field))
.isThrownBy(() -> this.processor.createHandler(badAnnotation, clazz, field))
.withMessage("Invalid annotation passed to TestBeanOverrideProcessor: expected @TestBean" +
" on field %s.%s", field.getDeclaringClass().getName(), field.getName());
}

12
spring-test/src/test/java/org/springframework/test/context/bean/override/easymock/EasyMockBeanOverrideMetadata.java → spring-test/src/test/java/org/springframework/test/context/bean/override/easymock/EasyMockBeanOverrideHandler.java
View File

@@ -25,22 +25,22 @@ import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.SingletonBeanRegistry;
import org.springframework.core.ResolvableType;
import org.springframework.lang.Nullable;
import org.springframework.test.context.bean.override.OverrideMetadata;
import org.springframework.test.context.bean.override.BeanOverrideHandler;
import static org.springframework.test.context.bean.override.BeanOverrideStrategy.REPLACE_OR_CREATE;
/**
* {@link OverrideMetadata} that provides support for {@link EasyMockBean @EasyMockBean}.
* {@link BeanOverrideHandler} that provides support for {@link EasyMockBean @EasyMockBean}.
*
* @author Sam Brannen
* @since 6.2
*/
class EasyMockBeanOverrideMetadata extends OverrideMetadata {
class EasyMockBeanOverrideHandler extends BeanOverrideHandler {
private final MockType mockType;
EasyMockBeanOverrideMetadata(Field field, Class<?> typeToOverride, @Nullable String beanName,
EasyMockBeanOverrideHandler(Field field, Class<?> typeToOverride, @Nullable String beanName,
MockType mockType) {
super(field, ResolvableType.forClass(typeToOverride), beanName, REPLACE_OR_CREATE);
@@ -49,7 +49,7 @@ class EasyMockBeanOverrideMetadata extends OverrideMetadata {
@Override
protected Object createOverride(String beanName, @Nullable BeanDefinition existingBeanDefinition,
protected Object createOverrideInstance(String beanName, @Nullable BeanDefinition existingBeanDefinition,
@Nullable Object existingBeanInstance) {
Class<?> typeToMock = getBeanType().getRawClass();
@@ -57,7 +57,7 @@ class EasyMockBeanOverrideMetadata extends OverrideMetadata {
}
@Override
protected void track(Object mock, SingletonBeanRegistry singletonBeanRegistry) {
protected void trackOverrideInstance(Object mock, SingletonBeanRegistry singletonBeanRegistry) {
getEasyMockBeans(singletonBeanRegistry).add(mock);
}

6
spring-test/src/test/java/org/springframework/test/context/bean/override/easymock/EasyMockBeanOverrideProcessor.java
View File

@@ -19,8 +19,8 @@ package org.springframework.test.context.bean.override.easymock;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import org.springframework.test.context.bean.override.BeanOverrideHandler;
import org.springframework.test.context.bean.override.BeanOverrideProcessor;
import org.springframework.test.context.bean.override.OverrideMetadata;
import org.springframework.util.StringUtils;
/**
@@ -32,10 +32,10 @@ import org.springframework.util.StringUtils;
class EasyMockBeanOverrideProcessor implements BeanOverrideProcessor {
@Override
public OverrideMetadata createMetadata(Annotation annotation, Class<?> testClass, Field field) {
public BeanOverrideHandler createHandler(Annotation annotation, Class<?> testClass, Field field) {
EasyMockBean easyMockBean = (EasyMockBean) annotation;
String beanName = (StringUtils.hasText(easyMockBean.name()) ? easyMockBean.name() : null);
return new EasyMockBeanOverrideMetadata(field, field.getType(), beanName, easyMockBean.mockType());
return new EasyMockBeanOverrideHandler(field, field.getType(), beanName, easyMockBean.mockType());
}
}

70
spring-test/src/test/java/org/springframework/test/context/bean/override/mockito/MockitoBeanOverrideMetadataTests.java → spring-test/src/test/java/org/springframework/test/context/bean/override/mockito/MockitoBeanOverrideHandlerTests.java
View File

@@ -25,86 +25,86 @@ import org.mockito.Answers;
import org.springframework.core.ResolvableType;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.test.context.bean.override.OverrideMetadata;
import org.springframework.test.context.bean.override.BeanOverrideHandler;
import org.springframework.util.ReflectionUtils;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link MockitoBeanOverrideMetadata}.
* Tests for {@link MockitoBeanOverrideHandler}.
*
* @author Stephane Nicoll
*/
class MockitoBeanOverrideMetadataTests {
class MockitoBeanOverrideHandlerTests {
@Test
void forTestClassSetsNameToNullIfAnnotationNameIsNull() {
List<OverrideMetadata> list = OverrideMetadata.forTestClass(SampleOneMock.class);
assertThat(list).singleElement().satisfies(metadata -> assertThat(metadata.getBeanName()).isNull());
List<BeanOverrideHandler> list = BeanOverrideHandler.forTestClass(SampleOneMock.class);
assertThat(list).singleElement().satisfies(handler -> assertThat(handler.getBeanName()).isNull());
}
@Test
void forTestClassSetsNameToAnnotationName() {
List<OverrideMetadata> list = OverrideMetadata.forTestClass(SampleOneMockWithName.class);
assertThat(list).singleElement().satisfies(metadata -> assertThat(metadata.getBeanName()).isEqualTo("anotherService"));
List<BeanOverrideHandler> list = BeanOverrideHandler.forTestClass(SampleOneMockWithName.class);
assertThat(list).singleElement().satisfies(handler -> assertThat(handler.getBeanName()).isEqualTo("anotherService"));
}
@Test
void isEqualToWithSameInstance() {
MockitoBeanOverrideMetadata metadata = createMetadata(sampleField("service"));
assertThat(metadata).isEqualTo(metadata);
assertThat(metadata).hasSameHashCodeAs(metadata);
MockitoBeanOverrideHandler handler = createBeanOverrideHandler(sampleField("service"));
assertThat(handler).isEqualTo(handler);
assertThat(handler).hasSameHashCodeAs(handler);
}
@Test
void isEqualToWithSameMetadata() {
MockitoBeanOverrideMetadata metadata = createMetadata(sampleField("service"));
MockitoBeanOverrideMetadata metadata2 = createMetadata(sampleField("service"));
assertThat(metadata).isEqualTo(metadata2);
assertThat(metadata).hasSameHashCodeAs(metadata2);
MockitoBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("service"));
MockitoBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("service"));
assertThat(handler1).isEqualTo(handler2);
assertThat(handler1).hasSameHashCodeAs(handler2);
}
@Test
void isNotEqualEqualToByTypeLookupWithSameMetadataButDifferentField() {
MockitoBeanOverrideMetadata metadata = createMetadata(sampleField("service"));
MockitoBeanOverrideMetadata metadata2 = createMetadata(sampleField("service2"));
assertThat(metadata).isNotEqualTo(metadata2);
MockitoBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("service"));
MockitoBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("service2"));
assertThat(handler1).isNotEqualTo(handler2);
}
@Test
void isEqualEqualToByNameLookupWithSameMetadataButDifferentField() {
MockitoBeanOverrideMetadata metadata = createMetadata(sampleField("service3"));
MockitoBeanOverrideMetadata metadata2 = createMetadata(sampleField("service4"));
assertThat(metadata).isEqualTo(metadata2);
assertThat(metadata).hasSameHashCodeAs(metadata2);
MockitoBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("service3"));
MockitoBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("service4"));
assertThat(handler1).isEqualTo(handler2);
assertThat(handler1).hasSameHashCodeAs(handler2);
}
@Test
void isNotEqualToWithSameMetadataButDifferentBeanName() {
MockitoBeanOverrideMetadata metadata = createMetadata(sampleField("service"));
MockitoBeanOverrideMetadata metadata2 = createMetadata(sampleField("service3"));
assertThat(metadata).isNotEqualTo(metadata2);
MockitoBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("service"));
MockitoBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("service3"));
assertThat(handler1).isNotEqualTo(handler2);
}
@Test
void isNotEqualToWithSameMetadataButDifferentExtraInterfaces() {
MockitoBeanOverrideMetadata metadata = createMetadata(sampleField("service"));
MockitoBeanOverrideMetadata metadata2 = createMetadata(sampleField("service5"));
assertThat(metadata).isNotEqualTo(metadata2);
MockitoBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("service"));
MockitoBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("service5"));
assertThat(handler1).isNotEqualTo(handler2);
}
@Test
void isNotEqualToWithSameMetadataButDifferentAnswers() {
MockitoBeanOverrideMetadata metadata = createMetadata(sampleField("service"));
MockitoBeanOverrideMetadata metadata2 = createMetadata(sampleField("service6"));
assertThat(metadata).isNotEqualTo(metadata2);
MockitoBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("service"));
MockitoBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("service6"));
assertThat(handler1).isNotEqualTo(handler2);
}
@Test
void isNotEqualToWithSameMetadataButDifferentSerializableFlag() {
MockitoBeanOverrideMetadata metadata = createMetadata(sampleField("service"));
MockitoBeanOverrideMetadata metadata2 = createMetadata(sampleField("service7"));
assertThat(metadata).isNotEqualTo(metadata2);
MockitoBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("service"));
MockitoBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("service7"));
assertThat(handler1).isNotEqualTo(handler2);
}
@@ -114,9 +114,9 @@ class MockitoBeanOverrideMetadataTests {
return field;
}
private MockitoBeanOverrideMetadata createMetadata(Field field) {
private MockitoBeanOverrideHandler createBeanOverrideHandler(Field field) {
MockitoBean annotation = AnnotatedElementUtils.getMergedAnnotation(field, MockitoBean.class);
return new MockitoBeanOverrideMetadata(field, ResolvableType.forClass(field.getType()), annotation);
return new MockitoBeanOverrideHandler(field, ResolvableType.forClass(field.getType()), annotation);
}

16
spring-test/src/test/java/org/springframework/test/context/bean/override/mockito/MockitoBeanOverrideProcessorTests.java
View File

@@ -23,7 +23,7 @@ import org.junit.jupiter.api.Test;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.lang.Nullable;
import org.springframework.test.context.bean.override.OverrideMetadata;
import org.springframework.test.context.bean.override.BeanOverrideHandler;
import org.springframework.test.context.bean.override.example.ExampleService;
import static org.assertj.core.api.Assertions.assertThat;
@@ -37,23 +37,23 @@ public class MockitoBeanOverrideProcessorTests {
private final MockitoBeanOverrideProcessor processor = new MockitoBeanOverrideProcessor();
@Test
void mockAnnotationCreatesMockMetadata() throws NoSuchFieldException {
void mockAnnotationCreatesMockitoBeanOverrideHandler() throws NoSuchFieldException {
MockitoBean annotation = AnnotationUtils.synthesizeAnnotation(MockitoBean.class);
Class<?> clazz = MockitoConf.class;
Field field = clazz.getField("a");
OverrideMetadata object = this.processor.createMetadata(annotation, clazz, field);
BeanOverrideHandler object = this.processor.createHandler(annotation, clazz, field);
assertThat(object).isExactlyInstanceOf(MockitoBeanOverrideMetadata.class);
assertThat(object).isExactlyInstanceOf(MockitoBeanOverrideHandler.class);
}
@Test
void spyAnnotationCreatesSpyMetadata() throws NoSuchFieldException {
void spyAnnotationCreatesMockitoSpyBeanOverrideHandler() throws NoSuchFieldException {
MockitoSpyBean annotation = AnnotationUtils.synthesizeAnnotation(MockitoSpyBean.class);
Class<?> clazz = MockitoConf.class;
Field field = clazz.getField("a");
OverrideMetadata object = this.processor.createMetadata(annotation, clazz, field);
BeanOverrideHandler object = this.processor.createHandler(annotation, clazz, field);
assertThat(object).isExactlyInstanceOf(MockitoSpyBeanOverrideMetadata.class);
assertThat(object).isExactlyInstanceOf(MockitoSpyBeanOverrideHandler.class);
}
@Test
@@ -63,7 +63,7 @@ public class MockitoBeanOverrideProcessorTests {
Annotation annotation = field.getAnnotation(Nullable.class);
assertThatIllegalStateException()
.isThrownBy(() -> this.processor.createMetadata(annotation, clazz, field))
.isThrownBy(() -> this.processor.createHandler(annotation, clazz, field))
.withMessage("Invalid annotation passed to MockitoBeanOverrideProcessor: expected either " +
"@MockitoBean or @MockitoSpyBean on field %s.%s", field.getDeclaringClass().getName(),
field.getName());

5
spring-test/src/test/java/org/springframework/test/context/bean/override/mockito/MockitoSpyBeanForFactoryBeanIntegrationTests.java
View File

@@ -32,6 +32,7 @@ import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
/**
* Test {@link MockitoSpyBean @MockitoSpyBean} for a factory bean configuration.
@@ -57,12 +58,12 @@ class MockitoSpyBeanForFactoryBeanIntegrationTests {
TestBean bean = this.applicationContext.getBean(TestBean.class);
assertThat(this.testBean).as("injected same").isSameAs(bean);
assertThat(bean.hello()).isEqualTo("hi");
Mockito.verify(bean).hello();
verify(bean).hello();
doReturn("sp-hi").when(this.testBean).hello();
assertThat(bean.hello()).as("after stubbing").isEqualTo("sp-hi");
Mockito.verify(bean, Mockito.times(2)).hello();
verify(bean, Mockito.times(2)).hello();
}
@Order(2)

64
spring-test/src/test/java/org/springframework/test/context/bean/override/mockito/MockitoSpyBeanOverrideMetadataTests.java → spring-test/src/test/java/org/springframework/test/context/bean/override/mockito/MockitoSpyBeanOverrideHandlerTests.java
View File

@@ -23,79 +23,79 @@ import org.junit.jupiter.api.Test;
import org.springframework.core.ResolvableType;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.test.context.bean.override.OverrideMetadata;
import org.springframework.test.context.bean.override.BeanOverrideHandler;
import org.springframework.util.ReflectionUtils;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link MockitoSpyBeanOverrideMetadata}.
* Tests for {@link MockitoSpyBeanOverrideHandler}.
*
* @author Stephane Nicoll
*/
class MockitoSpyBeanOverrideMetadataTests {
class MockitoSpyBeanOverrideHandlerTests {
@Test
void forTestClassSetsNameToNullIfAnnotationNameIsNull() {
List<OverrideMetadata> list = OverrideMetadata.forTestClass(SampleOneSpy.class);
assertThat(list).singleElement().satisfies(metadata -> assertThat(metadata.getBeanName()).isNull());
List<BeanOverrideHandler> list = BeanOverrideHandler.forTestClass(SampleOneSpy.class);
assertThat(list).singleElement().satisfies(handler -> assertThat(handler.getBeanName()).isNull());
}
@Test
void forTestClassSetsNameToAnnotationName() {
List<OverrideMetadata> list = OverrideMetadata.forTestClass(SampleOneSpyWithName.class);
assertThat(list).singleElement().satisfies(metadata -> assertThat(metadata.getBeanName()).isEqualTo("anotherService"));
List<BeanOverrideHandler> list = BeanOverrideHandler.forTestClass(SampleOneSpyWithName.class);
assertThat(list).singleElement().satisfies(handler -> assertThat(handler.getBeanName()).isEqualTo("anotherService"));
}
@Test
void isEqualToWithSameInstance() {
MockitoSpyBeanOverrideMetadata metadata = createMetadata(sampleField("service"));
assertThat(metadata).isEqualTo(metadata);
assertThat(metadata).hasSameHashCodeAs(metadata);
MockitoSpyBeanOverrideHandler handler = createBeanOverrideHandler(sampleField("service"));
assertThat(handler).isEqualTo(handler);
assertThat(handler).hasSameHashCodeAs(handler);
}
@Test
void isEqualToWithSameMetadata() {
MockitoSpyBeanOverrideMetadata metadata = createMetadata(sampleField("service"));
MockitoSpyBeanOverrideMetadata metadata2 = createMetadata(sampleField("service"));
assertThat(metadata).isEqualTo(metadata2);
assertThat(metadata).hasSameHashCodeAs(metadata2);
MockitoSpyBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("service"));
MockitoSpyBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("service"));
assertThat(handler1).isEqualTo(handler2);
assertThat(handler1).hasSameHashCodeAs(handler2);
}
@Test
void isNotEqualToByTypeLookupWithSameMetadataButDifferentField() {
MockitoSpyBeanOverrideMetadata metadata = createMetadata(sampleField("service"));
MockitoSpyBeanOverrideMetadata metadata2 = createMetadata(sampleField("service2"));
assertThat(metadata).isNotEqualTo(metadata2);
MockitoSpyBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("service"));
MockitoSpyBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("service2"));
assertThat(handler1).isNotEqualTo(handler2);
}
@Test
void isEqualToByNameLookupWithSameMetadataButDifferentField() {
MockitoSpyBeanOverrideMetadata metadata = createMetadata(sampleField("service3"));
MockitoSpyBeanOverrideMetadata metadata2 = createMetadata(sampleField("service4"));
assertThat(metadata).isEqualTo(metadata2);
assertThat(metadata).hasSameHashCodeAs(metadata2);
MockitoSpyBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("service3"));
MockitoSpyBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("service4"));
assertThat(handler1).isEqualTo(handler2);
assertThat(handler1).hasSameHashCodeAs(handler2);
}
@Test
void isNotEqualToWithSameMetadataButDifferentBeanName() {
MockitoSpyBeanOverrideMetadata metadata = createMetadata(sampleField("service"));
MockitoSpyBeanOverrideMetadata metadata2 = createMetadata(sampleField("service3"));
assertThat(metadata).isNotEqualTo(metadata2);
MockitoSpyBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("service"));
MockitoSpyBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("service3"));
assertThat(handler1).isNotEqualTo(handler2);
}
@Test
void isNotEqualToWithSameMetadataButDifferentReset() {
MockitoSpyBeanOverrideMetadata metadata = createMetadata(sampleField("service"));
MockitoSpyBeanOverrideMetadata metadata2 = createMetadata(sampleField("service5"));
assertThat(metadata).isNotEqualTo(metadata2);
MockitoSpyBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("service"));
MockitoSpyBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("service5"));
assertThat(handler1).isNotEqualTo(handler2);
}
@Test
void isNotEqualToWithSameMetadataButDifferentProxyTargetAwareFlag() {
MockitoSpyBeanOverrideMetadata metadata = createMetadata(sampleField("service"));
MockitoSpyBeanOverrideMetadata metadata2 = createMetadata(sampleField("service6"));
assertThat(metadata).isNotEqualTo(metadata2);
MockitoSpyBeanOverrideHandler handler1 = createBeanOverrideHandler(sampleField("service"));
MockitoSpyBeanOverrideHandler handler2 = createBeanOverrideHandler(sampleField("service6"));
assertThat(handler1).isNotEqualTo(handler2);
}
@@ -105,9 +105,9 @@ class MockitoSpyBeanOverrideMetadataTests {
return field;
}
private MockitoSpyBeanOverrideMetadata createMetadata(Field field) {
private MockitoSpyBeanOverrideHandler createBeanOverrideHandler(Field field) {
MockitoSpyBean annotation = AnnotatedElementUtils.getMergedAnnotation(field, MockitoSpyBean.class);
return new MockitoSpyBeanOverrideMetadata(field, ResolvableType.forClass(field.getType()), annotation);
return new MockitoSpyBeanOverrideHandler(field, ResolvableType.forClass(field.getType()), annotation);
}