Merge branch '1.5.x'

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

@@ -184,14 +184,15 @@ public class MockitoPostProcessor extends InstantiationAwareBeanPostProcessorAda
 			BeanDefinitionRegistry registry, MockDefinition definition, Field field) {
 		RootBeanDefinition beanDefinition = createBeanDefinition(definition);
 		String beanName = getBeanName(beanFactory, registry, definition, beanDefinition);
+		String transformedBeanName = BeanFactoryUtils.transformedBeanName(beanName);
 		beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(1,
 				beanName);
-		if (registry.containsBeanDefinition(beanName)) {
-			registry.removeBeanDefinition(beanName);
+		if (registry.containsBeanDefinition(transformedBeanName)) {
+			registry.removeBeanDefinition(transformedBeanName);
 		}
-		registry.registerBeanDefinition(beanName, beanDefinition);
+		registry.registerBeanDefinition(transformedBeanName, beanDefinition);
 		Object mock = createMock(definition, beanName);
-		beanFactory.registerSingleton(beanName, mock);
+		beanFactory.registerSingleton(transformedBeanName, mock);
 		this.mockitoBeans.add(mock);
 		this.beanNameRegistry.put(definition, beanName);
 		if (field != null) {

spring-boot-test/src/main/java/org/springframework/boot/test/web/client/TestRestTemplate.java

@@ -984,14 +984,16 @@ public class TestRestTemplate {
 	 */
 	public TestRestTemplate withBasicAuth(String username, String password) {
 		RestTemplate restTemplate = new RestTemplate();
-		restTemplate.setErrorHandler(getRestTemplate().getErrorHandler());
 		restTemplate.setMessageConverters(getRestTemplate().getMessageConverters());
 		restTemplate.setInterceptors(
 				removeBasicAuthInterceptorIfPresent(getRestTemplate().getInterceptors()));
 		restTemplate.setRequestFactory(getRestTemplate().getRequestFactory());
 		restTemplate.setUriTemplateHandler(getRestTemplate().getUriTemplateHandler());
-		return new TestRestTemplate(restTemplate, username, password,
-				this.httpClientOptions);
+		TestRestTemplate testRestTemplate = new TestRestTemplate(restTemplate, username,
+				password, this.httpClientOptions);
+		testRestTemplate.getRestTemplate()
+				.setErrorHandler(getRestTemplate().getErrorHandler());
+		return testRestTemplate;
 	}
 
 	private List<ClientHttpRequestInterceptor> removeBasicAuthInterceptorIfPresent(

spring-boot-test/src/test/java/org/springframework/boot/test/mock/mockito/MockBeanForBeanFactoryIntegrationTests.java

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2012-2016 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 org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.springframework.beans.factory.FactoryBean;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+
+/**
+ * Test {@link MockBean} for a factory bean.
+ *
+ * @author Phillip Webb
+ */
+@RunWith(SpringRunner.class)
+public class MockBeanForBeanFactoryIntegrationTests {
+
+	// gh-7439
+
+	@MockBean
+	private TestFactoryBean testFactoryBean;
+
+	@Autowired
+	private ApplicationContext applicationContext;
+
+	@Test
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	public void testName() throws Exception {
+		TestBean testBean = mock(TestBean.class);
+		given(testBean.hello()).willReturn("amock");
+		given(this.testFactoryBean.getObjectType()).willReturn((Class) TestBean.class);
+		given(this.testFactoryBean.getObject()).willReturn(testBean);
+		TestBean bean = this.applicationContext.getBean(TestBean.class);
+		assertThat(bean.hello()).isEqualTo("amock");
+	}
+
+	@Configuration
+	static class Config {
+
+		@Bean
+		public TestFactoryBean testFactoryBean() {
+			return new TestFactoryBean();
+		}
+
+	}
+
+	static class TestFactoryBean implements FactoryBean<TestBean> {
+
+		@Override
+		public TestBean getObject() throws Exception {
+			return new TestBean() {
+
+				@Override
+				public String hello() {
+					return "normal";
+				}
+
+			};
+		}
+
+		@Override
+		public Class<?> getObjectType() {
+			return TestBean.class;
+		}
+
+		@Override
+		public boolean isSingleton() {
+			return false;
+		}
+
+	}
+
+	interface TestBean {
+
+		String hello();
+
+	}
+
+}

spring-boot-test/src/test/java/org/springframework/boot/test/web/client/TestRestTemplateTests.java

@@ -34,6 +34,7 @@ import org.springframework.http.client.support.BasicAuthorizationInterceptor;
 import org.springframework.test.util.ReflectionTestUtils;
 import org.springframework.util.ReflectionUtils;
 import org.springframework.util.ReflectionUtils.MethodCallback;
+import org.springframework.web.client.ResponseErrorHandler;
 import org.springframework.web.client.RestOperations;
 import org.springframework.web.client.RestTemplate;
 
@@ -157,25 +158,32 @@ public class TestRestTemplateTests {
 
 	@Test
 	public void withBasicAuthReplacesBasicAuthInterceptorWhenAlreadyPresent() {
-		TestRestTemplate originalTemplate = new TestRestTemplate("foo", "bar");
-		TestRestTemplate basicAuthTemplate = originalTemplate.withBasicAuth("user",
-				"password");
-		assertThat(basicAuthTemplate.getRestTemplate().getMessageConverters())
+		TestRestTemplate original = new TestRestTemplate("foo", "bar");
+		TestRestTemplate basicAuth = original.withBasicAuth("user", "password");
+		assertThat(basicAuth.getRestTemplate().getMessageConverters())
 				.containsExactlyElementsOf(
-						originalTemplate.getRestTemplate().getMessageConverters());
-		assertThat(basicAuthTemplate.getRestTemplate().getRequestFactory())
+						original.getRestTemplate().getMessageConverters());
+		assertThat(basicAuth.getRestTemplate().getRequestFactory())
 				.isInstanceOf(InterceptingClientHttpRequestFactory.class);
 		assertThat(ReflectionTestUtils.getField(
-				basicAuthTemplate.getRestTemplate().getRequestFactory(),
-				"requestFactory"))
+				basicAuth.getRestTemplate().getRequestFactory(), "requestFactory"))
 						.isInstanceOf(CustomHttpComponentsClientHttpRequestFactory.class);
-		assertThat(basicAuthTemplate.getRestTemplate().getUriTemplateHandler())
-				.isSameAs(originalTemplate.getRestTemplate().getUriTemplateHandler());
-		assertThat(basicAuthTemplate.getRestTemplate().getInterceptors())
-				.containsExactlyElementsOf(
-						originalTemplate.getRestTemplate().getInterceptors());
-		assertBasicAuthorizationInterceptorCredentials(basicAuthTemplate, "user",
+		assertThat(basicAuth.getRestTemplate().getUriTemplateHandler())
+				.isSameAs(original.getRestTemplate().getUriTemplateHandler());
+		assertThat(basicAuth.getRestTemplate().getInterceptors())
+				.containsExactlyElementsOf(original.getRestTemplate().getInterceptors());
+		assertBasicAuthorizationInterceptorCredentials(basicAuth, "user", "password");
+	}
+
+	@Test
+	public void withBasicAuthDoesNotResetErrorHandler() throws Exception {
+		TestRestTemplate originalTemplate = new TestRestTemplate("foo", "bar");
+		ResponseErrorHandler errorHandler = mock(ResponseErrorHandler.class);
+		originalTemplate.getRestTemplate().setErrorHandler(errorHandler);
+		TestRestTemplate basicAuthTemplate = originalTemplate.withBasicAuth("user",
 				"password");
+		assertThat(basicAuthTemplate.getRestTemplate().getErrorHandler())
+				.isSameAs(errorHandler);
 	}
 
 	private void assertBasicAuthorizationInterceptorCredentials(