Source code
package org.springframework.test.context.bean.override.convention;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import org.springframework.core.MethodIntrospector;
import org.springframework.core.ResolvableType;
import org.springframework.test.context.TestContextAnnotationUtils;
import org.springframework.test.context.bean.override.BeanOverrideProcessor;
import org.springframework.test.context.bean.override.BeanOverrideStrategy;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.ReflectionUtils;
import org.springframework.util.ReflectionUtils.MethodFilter;
import static org.springframework.test.context.bean.override.BeanOverrideStrategy.REPLACE;
import static org.springframework.test.context.bean.override.BeanOverrideStrategy.REPLACE_OR_CREATE;
class TestBeanOverrideProcessor implements BeanOverrideProcessor {
@Override
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()));
}
String beanName = (!testBean.name().isBlank() ? testBean.name() : null);
String methodName = testBean.methodName();
BeanOverrideStrategy strategy = (testBean.enforceOverride() ? REPLACE : REPLACE_OR_CREATE);
Method factoryMethod;
if (!methodName.isBlank()) {
factoryMethod = findTestBeanFactoryMethod(field.getDeclaringClass(), field.getType(), methodName);
}
else {
List<String> candidateMethodNames = new ArrayList<>();
candidateMethodNames.add(field.getName());
if (beanName != null) {
candidateMethodNames.add(beanName);
}
factoryMethod = findTestBeanFactoryMethod(field.getDeclaringClass(), field.getType(), candidateMethodNames);
}
return new TestBeanOverrideHandler(
field, ResolvableType.forField(field, testClass), beanName, testBean.contextName(), strategy, factoryMethod);
}
Method findTestBeanFactoryMethod(Class<?> clazz, Class<?> methodReturnType, String... methodNames) {
return findTestBeanFactoryMethod(clazz, methodReturnType, List.of(methodNames));
}
Method findTestBeanFactoryMethod(Class<?> clazz, Class<?> methodReturnType, Collection<String> methodNames) {
Assert.notEmpty(methodNames, "At least one candidate method name is required");
Set<Method> methods = new LinkedHashSet<>();
Set<String> originalNames = new LinkedHashSet<>(methodNames);
for (String methodName : methodNames) {
int indexOfHash = methodName.lastIndexOf('#');
if (indexOfHash != -1) {
String className = methodName.substring(0, indexOfHash).trim();
Assert.hasText(className, () -> "No class name present in fully-qualified method name: " + methodName);
String methodNameToUse = methodName.substring(indexOfHash + 1).trim();
Assert.hasText(methodNameToUse, () -> "No method name present in fully-qualified method name: " + methodName);
Class<?> declaringClass;
try {
declaringClass = ClassUtils.forName(className, getClass().getClassLoader());
}
catch (ClassNotFoundException | LinkageError ex) {
throw new IllegalStateException(
"Failed to load class for fully-qualified method name: " + methodName, ex);
}
Method externalMethod = ReflectionUtils.findMethod(declaringClass, methodNameToUse);
Assert.state(externalMethod != null && Modifier.isStatic(externalMethod.getModifiers()) &&
methodReturnType.isAssignableFrom(externalMethod.getReturnType()), () ->
"No static method found named %s in %s with return type %s".formatted(
methodNameToUse, className, methodReturnType.getName()));
methods.add(externalMethod);
originalNames.remove(methodName);
}
}
Set<String> supportedNames = new LinkedHashSet<>(originalNames);
MethodFilter methodFilter = method -> (Modifier.isStatic(method.getModifiers()) &&
supportedNames.contains(method.getName()) &&
methodReturnType.isAssignableFrom(method.getReturnType()));
findMethods(methods, clazz, methodFilter);
String methodNamesDescription = supportedNames.stream()
.map(name -> name + "()").collect(Collectors.joining(" or "));
Assert.state(!methods.isEmpty(), () ->
"No static method found named %s in %s with return type %s".formatted(
methodNamesDescription, clazz.getName(), methodReturnType.getName()));
long uniqueMethodNameCount = methods.stream().map(Method::getName).distinct().count();
Assert.state(uniqueMethodNameCount == 1, () ->
"Found %d competing static methods named %s in %s with return type %s".formatted(
uniqueMethodNameCount, methodNamesDescription, clazz.getName(), methodReturnType.getName()));
return methods.iterator().next();
}
private static Set<Method> findMethods(Set<Method> methods, Class<?> clazz, MethodFilter methodFilter) {
methods.addAll(MethodIntrospector.selectMethods(clazz, methodFilter));
if (methods.isEmpty() && TestContextAnnotationUtils.searchEnclosingClass(clazz)) {
findMethods(methods, clazz.getEnclosingClass(), methodFilter);
}
return methods;
}
}