Consider @Primary annotation when using @MockBean, make @MockBean/@SpyBean behave consistently

spring-boot-project/spring-boot-test/src/main/java/org/springframework/boot/test/mock/mockito/Definition.java

@@ -16,6 +16,8 @@
 
 package org.springframework.boot.test.mock.mockito;
 
+import org.springframework.core.ResolvableType;
+import org.springframework.util.Assert;
 import org.springframework.util.ObjectUtils;
 
 /**
@@ -36,12 +38,16 @@ abstract class Definition {
 
 	private final QualifierDefinition qualifier;
 
+	private final ResolvableType type;
+
 	Definition(String name, MockReset reset, boolean proxyTargetAware,
-			QualifierDefinition qualifier) {
+			QualifierDefinition qualifier, ResolvableType type) {
+		Assert.notNull(type, "type must not be null");
 		this.name = name;
 		this.reset = (reset != null ? reset : MockReset.AFTER);
 		this.proxyTargetAware = proxyTargetAware;
 		this.qualifier = qualifier;
+		this.type = type;
 	}
 
 	/**
@@ -76,6 +82,14 @@ public QualifierDefinition getQualifier() {
 		return this.qualifier;
 	}
 
+	/**
+	 * Get type to mock or spy.
+	 * @return the type; never {@code null}
+	 */
+	public ResolvableType getType() {
+		return this.type;
+	}
+
 	@Override
 	public int hashCode() {
 		int result = 1;
@@ -84,6 +98,7 @@ public int hashCode() {
 		result = MULTIPLIER * result
 				+ ObjectUtils.nullSafeHashCode(this.proxyTargetAware);
 		result = MULTIPLIER * result + ObjectUtils.nullSafeHashCode(this.qualifier);
+		result = MULTIPLIER * result + ObjectUtils.nullSafeHashCode(this.type);
 		return result;
 	}
 
@@ -102,6 +117,7 @@ public boolean equals(Object obj) {
 		result = result && ObjectUtils.nullSafeEquals(this.proxyTargetAware,
 				other.proxyTargetAware);
 		result = result && ObjectUtils.nullSafeEquals(this.qualifier, other.qualifier);
+		result = result && ObjectUtils.nullSafeEquals(this.type, other.type);
 		return result;
 	}
 

spring-boot-project/spring-boot-test/src/main/java/org/springframework/boot/test/mock/mockito/MockDefinition.java

@@ -27,7 +27,6 @@
 
 import org.springframework.core.ResolvableType;
 import org.springframework.core.style.ToStringCreator;
-import org.springframework.util.Assert;
 import org.springframework.util.ObjectUtils;
 import org.springframework.util.StringUtils;
 
@@ -40,8 +39,6 @@ class MockDefinition extends Definition {
 
 	private static final int MULTIPLIER = 31;
 
-	private final ResolvableType typeToMock;
-
 	private final Set<Class<?>> extraInterfaces;
 
 	private final Answers answer;
@@ -51,9 +48,7 @@ class MockDefinition extends Definition {
 	MockDefinition(String name, ResolvableType typeToMock, Class<?>[] extraInterfaces,
 			Answers answer, boolean serializable, MockReset reset,
 			QualifierDefinition qualifier) {
-		super(name, reset, false, qualifier);
-		Assert.notNull(typeToMock, "TypeToMock must not be null");
-		this.typeToMock = typeToMock;
+		super(name, reset, false, qualifier, typeToMock);
 		this.extraInterfaces = asClassSet(extraInterfaces);
 		this.answer = (answer != null ? answer : Answers.RETURNS_DEFAULTS);
 		this.serializable = serializable;
@@ -72,7 +67,7 @@ private Set<Class<?>> asClassSet(Class<?>[] classes) {
 	 * @return the type to mock; never {@code null}
 	 */
 	public ResolvableType getTypeToMock() {
-		return this.typeToMock;
+		return super.getType();
 	}
 
 	/**
@@ -102,7 +97,6 @@ public boolean isSerializable() {
 	@Override
 	public int hashCode() {
 		int result = super.hashCode();
-		result = MULTIPLIER * result + ObjectUtils.nullSafeHashCode(this.typeToMock);
 		result = MULTIPLIER * result + ObjectUtils.nullSafeHashCode(this.extraInterfaces);
 		result = MULTIPLIER * result + ObjectUtils.nullSafeHashCode(this.answer);
 		result = MULTIPLIER * result + Boolean.hashCode(this.serializable);
@@ -119,7 +113,6 @@ public boolean equals(Object obj) {
 		}
 		MockDefinition other = (MockDefinition) obj;
 		boolean result = super.equals(obj);
-		result = result && ObjectUtils.nullSafeEquals(this.typeToMock, other.typeToMock);
 		result = result && ObjectUtils.nullSafeEquals(this.extraInterfaces,
 				other.extraInterfaces);
 		result = result && ObjectUtils.nullSafeEquals(this.answer, other.answer);
@@ -130,7 +123,7 @@ public boolean equals(Object obj) {
 	@Override
 	public String toString() {
 		return new ToStringCreator(this).append("name", getName())
-				.append("typeToMock", this.typeToMock)
+				.append("typeToMock", super.getType())
 				.append("extraInterfaces", this.extraInterfaces)
 				.append("answer", this.answer).append("serializable", this.serializable)
 				.append("reset", getReset()).toString();
@@ -153,7 +146,7 @@ public <T> T createMock(String name) {
 		if (this.serializable) {
 			settings.serializable();
 		}
-		return (T) Mockito.mock(this.typeToMock.resolve(), settings);
+		return (T) Mockito.mock(this.getTypeToMock().resolve(), settings);
 	}
 
 }

spring-boot-project/spring-boot-test/src/main/java/org/springframework/boot/test/mock/mockito/MockitoBeanNameFinder.java

@@ -0,0 +1,132 @@
+/*
+ * Copyright 2012-2017 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
+ *
+ *      http://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.boot.test.mock.mockito;
+
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.TreeSet;
+
+import javax.annotation.Nullable;
+
+import org.springframework.aop.scope.ScopedProxyUtils;
+import org.springframework.beans.factory.BeanFactoryUtils;
+import org.springframework.beans.factory.FactoryBean;
+import org.springframework.beans.factory.NoUniqueBeanDefinitionException;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.beans.factory.support.BeanDefinitionRegistry;
+import org.springframework.beans.factory.support.BeanNameGenerator;
+import org.springframework.beans.factory.support.DefaultBeanNameGenerator;
+import org.springframework.beans.factory.support.RootBeanDefinition;
+import org.springframework.core.ResolvableType;
+import org.springframework.util.StringUtils;
+
+/**
+ * Encapsulates the task to find the bean name which can be mocked or spied. Offers
+ * {@link MockitoBeanNameFinder#getOrGenerateBeanName} for that purpose. Used by
+ * {@link MockitoPostProcessor}.
+ *
+ * @author Andreas Neiser
+ */
+final class MockitoBeanNameFinder {
+
+	private MockitoBeanNameFinder() {
+		// only static method calls
+	}
+
+	private static final String FACTORY_BEAN_OBJECT_TYPE = "factoryBeanObjectType";
+
+	private static final BeanNameGenerator BEAN_NAME_GENERATOR = new DefaultBeanNameGenerator();
+
+	static String getOrGenerateBeanName(ConfigurableListableBeanFactory beanFactory,
+			BeanDefinitionRegistry registry, Definition definition,
+			RootBeanDefinition beanDefinition) {
+		Set<String> existingBeans = findCandidateBeans(beanFactory, definition);
+		if (existingBeans.isEmpty()) {
+			return BEAN_NAME_GENERATOR.generateBeanName(beanDefinition, registry);
+		}
+		return getBeanName(registry, existingBeans, definition);
+	}
+
+	private static String getBeanName(BeanDefinitionRegistry registry,
+			Set<String> existingBeanNames, Definition definition) {
+		if (StringUtils.hasText(definition.getName())) {
+			return definition.getName();
+		}
+		if (existingBeanNames.size() == 1) {
+			return existingBeanNames.iterator().next();
+		}
+		String beanName = findPrimaryBeanName(registry, existingBeanNames,
+				definition.getType());
+		if (beanName == null) {
+			throw new IllegalStateException("Unable to register bean "
+					+ definition.getType()
+					+ " expected a single matching/primary bean to replace but found "
+					+ existingBeanNames);
+		}
+		return beanName;
+	}
+
+	@Nullable
+	private static String findPrimaryBeanName(BeanDefinitionRegistry registry,
+			Set<String> existingBeanNames, ResolvableType type) {
+		String primaryBeanName = null;
+		for (String existingBeanName : existingBeanNames) {
+			BeanDefinition beanDefinition = registry.getBeanDefinition(existingBeanName);
+			if (beanDefinition.isPrimary()) {
+				if (primaryBeanName != null) {
+					throw new NoUniqueBeanDefinitionException(type.resolve(),
+							existingBeanNames.size(),
+							"more than one 'primary' bean found among candidates: "
+									+ existingBeanNames);
+				}
+				primaryBeanName = existingBeanName;
+			}
+		}
+		return primaryBeanName;
+	}
+
+	private static Set<String> findCandidateBeans(
+			ConfigurableListableBeanFactory beanFactory, Definition definition) {
+		QualifierDefinition qualifier = definition.getQualifier();
+		Set<String> candidates = new TreeSet<>();
+		for (String candidate : getExistingBeans(beanFactory, definition.getType())) {
+			if (qualifier == null || qualifier.matches(beanFactory, candidate)) {
+				candidates.add(candidate);
+			}
+		}
+		return candidates;
+	}
+
+	private static Set<String> getExistingBeans(
+			ConfigurableListableBeanFactory beanFactory, ResolvableType type) {
+		Set<String> beans = new LinkedHashSet<>(
+				Arrays.asList(beanFactory.getBeanNamesForType(type)));
+		String resolvedTypeName = type.resolve(Object.class).getName();
+		for (String beanName : beanFactory.getBeanNamesForType(FactoryBean.class)) {
+			beanName = BeanFactoryUtils.transformedBeanName(beanName);
+			BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
+			if (resolvedTypeName
+					.equals(beanDefinition.getAttribute(FACTORY_BEAN_OBJECT_TYPE))) {
+				beans.add(beanName);
+			}
+		}
+		beans.removeIf(ScopedProxyUtils::isScopedTarget);
+		return beans;
+	}
+}