Merge branch '1.5.x'

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/couchbase/CouchbaseAutoConfiguration.java

@@ -44,7 +44,7 @@ import org.springframework.data.couchbase.config.CouchbaseConfigurer;
  * @since 1.4.0
  */
 @Configuration
-@ConditionalOnClass({ CouchbaseBucket.class, Cluster.class })
+@ConditionalOnClass({ CouchbaseBucket.class, Cluster.class, CouchbaseConfigurer.class })
 @Conditional(CouchbaseAutoConfiguration.CouchbaseCondition.class)
 @EnableConfigurationProperties(CouchbaseProperties.class)
 public class CouchbaseAutoConfiguration {

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/kafka/KafkaProperties.java

@@ -172,8 +172,7 @@ public class KafkaProperties {
 		}
 		catch (IOException ex) {
 			throw new IllegalStateException(
-					String.format("Resource '%s' must be on a file system", resource),
-					ex);
+					"Resource '" + resource + "' must be on a file system", ex);
 		}
 	}
 

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/web/ServerProperties.java

@@ -874,14 +874,20 @@ public class ServerProperties
 		}
 
 		private void customizeConnectionTimeout(
-				TomcatEmbeddedServletContainerFactory factory, int connectionTimeout) {
-			for (Connector connector : factory.getAdditionalTomcatConnectors()) {
-				ProtocolHandler handler = connector.getProtocolHandler();
-				if (handler instanceof AbstractProtocol) {
-					AbstractProtocol<?> protocol = (AbstractProtocol<?>) handler;
-					protocol.setConnectionTimeout(connectionTimeout);
+				TomcatEmbeddedServletContainerFactory factory,
+				final int connectionTimeout) {
+			factory.addConnectorCustomizers(new TomcatConnectorCustomizer() {
+
+				@Override
+				public void customize(Connector connector) {
+					ProtocolHandler handler = connector.getProtocolHandler();
+					if (handler instanceof AbstractProtocol) {
+						AbstractProtocol<?> protocol = (AbstractProtocol<?>) handler;
+						protocol.setConnectionTimeout(connectionTimeout);
+					}
 				}
-			}
+
+			});
 		}
 
 		private void customizeRemoteIpValve(ServerProperties properties,

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/EnableAutoConfigurationImportSelectorTests.java

@@ -185,8 +185,8 @@ public class EnableAutoConfigurationImportSelectorTests {
 	public void nonAutoConfigurationClassNameExclusionsWhenPresentOnClassPathShouldThrowException()
 			throws Exception {
 		configureExclusions(new String[0],
-				new String[] {
-						"org.springframework.boot.autoconfigure.EnableAutoConfigurationImportSelectorTests.TestConfiguration" },
+				new String[] { "org.springframework.boot.autoconfigure."
+						+ "EnableAutoConfigurationImportSelectorTests.TestConfiguration" },
 				new String[0]);
 		this.expected.expect(IllegalStateException.class);
 		this.importSelector.selectImports(this.annotationMetadata);
@@ -195,8 +195,9 @@ public class EnableAutoConfigurationImportSelectorTests {
 	@Test
 	public void nonAutoConfigurationPropertyExclusionsWhenPresentOnClassPathShouldThrowException()
 			throws Exception {
-		configureExclusions(new String[0], new String[0], new String[] {
-				"org.springframework.boot.autoconfigure.EnableAutoConfigurationImportSelectorTests.TestConfiguration" });
+		configureExclusions(new String[0], new String[0],
+				new String[] { "org.springframework.boot.autoconfigure."
+						+ "EnableAutoConfigurationImportSelectorTests.TestConfiguration" });
 		this.expected.expect(IllegalStateException.class);
 		this.importSelector.selectImports(this.annotationMetadata);
 	}

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/kafka/KafkaAutoConfigurationTests.java

@@ -79,38 +79,35 @@ public class KafkaAutoConfigurationTests {
 		DefaultKafkaConsumerFactory<?, ?> consumerFactory = this.context
 				.getBean(DefaultKafkaConsumerFactory.class);
 		@SuppressWarnings("unchecked")
-		Map<String, Object> consumerProps = (Map<String, Object>) new DirectFieldAccessor(
+		Map<String, Object> configs = (Map<String, Object>) new DirectFieldAccessor(
 				consumerFactory).getPropertyValue("configs");
 		// common
-		assertThat(consumerProps.get(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG))
+		assertThat(configs.get(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG))
 				.isEqualTo(Collections.singletonList("foo:1234"));
-		assertThat(consumerProps.get(SslConfigs.SSL_KEY_PASSWORD_CONFIG)).isEqualTo("p1");
-		assertThat((String) consumerProps.get(SslConfigs.SSL_KEYSTORE_LOCATION_CONFIG))
+		assertThat(configs.get(SslConfigs.SSL_KEY_PASSWORD_CONFIG)).isEqualTo("p1");
+		assertThat((String) configs.get(SslConfigs.SSL_KEYSTORE_LOCATION_CONFIG))
 				.endsWith(File.separator + "ksLoc");
-		assertThat(consumerProps.get(SslConfigs.SSL_KEYSTORE_PASSWORD_CONFIG))
-				.isEqualTo("p2");
-		assertThat((String) consumerProps.get(SslConfigs.SSL_TRUSTSTORE_LOCATION_CONFIG))
+		assertThat(configs.get(SslConfigs.SSL_KEYSTORE_PASSWORD_CONFIG)).isEqualTo("p2");
+		assertThat((String) configs.get(SslConfigs.SSL_TRUSTSTORE_LOCATION_CONFIG))
 				.endsWith(File.separator + "tsLoc");
-		assertThat(consumerProps.get(SslConfigs.SSL_TRUSTSTORE_PASSWORD_CONFIG))
+		assertThat(configs.get(SslConfigs.SSL_TRUSTSTORE_PASSWORD_CONFIG))
 				.isEqualTo("p3");
 		// consumer
-		assertThat(consumerProps.get(ConsumerConfig.CLIENT_ID_CONFIG)).isEqualTo("ccid"); // override
-		assertThat(consumerProps.get(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG))
+		assertThat(configs.get(ConsumerConfig.CLIENT_ID_CONFIG)).isEqualTo("ccid"); // override
+		assertThat(configs.get(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG))
 				.isEqualTo(Boolean.FALSE);
-		assertThat(consumerProps.get(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG))
+		assertThat(configs.get(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG))
 				.isEqualTo(123L);
-		assertThat(consumerProps.get(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG))
+		assertThat(configs.get(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG))
 				.isEqualTo("earliest");
-		assertThat(consumerProps.get(ConsumerConfig.FETCH_MAX_WAIT_MS_CONFIG))
-				.isEqualTo(456);
-		assertThat(consumerProps.get(ConsumerConfig.FETCH_MIN_BYTES_CONFIG))
-				.isEqualTo(789);
-		assertThat(consumerProps.get(ConsumerConfig.GROUP_ID_CONFIG)).isEqualTo("bar");
-		assertThat(consumerProps.get(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG))
+		assertThat(configs.get(ConsumerConfig.FETCH_MAX_WAIT_MS_CONFIG)).isEqualTo(456);
+		assertThat(configs.get(ConsumerConfig.FETCH_MIN_BYTES_CONFIG)).isEqualTo(789);
+		assertThat(configs.get(ConsumerConfig.GROUP_ID_CONFIG)).isEqualTo("bar");
+		assertThat(configs.get(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG))
 				.isEqualTo(234);
-		assertThat(consumerProps.get(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG))
+		assertThat(configs.get(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG))
 				.isEqualTo(LongDeserializer.class);
-		assertThat(consumerProps.get(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG))
+		assertThat(configs.get(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG))
 				.isEqualTo(IntegerDeserializer.class);
 	}
 
@@ -119,7 +116,6 @@ public class KafkaAutoConfigurationTests {
 		load("spring.kafka.clientId=cid", "spring.kafka.producer.acks=all",
 				"spring.kafka.producer.batch-size=20",
 				"spring.kafka.producer.bootstrap-servers=bar:1234", // test override
-																	// common
 				"spring.kafka.producer.buffer-memory=12345",
 				"spring.kafka.producer.compression-type=gzip",
 				"spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.LongSerializer",
@@ -133,39 +129,35 @@ public class KafkaAutoConfigurationTests {
 		DefaultKafkaProducerFactory<?, ?> producerFactory = this.context
 				.getBean(DefaultKafkaProducerFactory.class);
 		@SuppressWarnings("unchecked")
-		Map<String, Object> producerProps = (Map<String, Object>) new DirectFieldAccessor(
+		Map<String, Object> configs = (Map<String, Object>) new DirectFieldAccessor(
 				producerFactory).getPropertyValue("configs");
 		// common
-		assertThat(producerProps.get(ProducerConfig.CLIENT_ID_CONFIG)).isEqualTo("cid");
+		assertThat(configs.get(ProducerConfig.CLIENT_ID_CONFIG)).isEqualTo("cid");
 		// producer
-		assertThat(producerProps.get(ProducerConfig.ACKS_CONFIG)).isEqualTo("all");
-		assertThat(producerProps.get(ProducerConfig.BATCH_SIZE_CONFIG)).isEqualTo(20);
-		assertThat(producerProps.get(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG))
+		assertThat(configs.get(ProducerConfig.ACKS_CONFIG)).isEqualTo("all");
+		assertThat(configs.get(ProducerConfig.BATCH_SIZE_CONFIG)).isEqualTo(20);
+		assertThat(configs.get(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG))
 				.isEqualTo(Collections.singletonList("bar:1234")); // override
-		assertThat(producerProps.get(ProducerConfig.BUFFER_MEMORY_CONFIG))
-				.isEqualTo(12345L);
-		assertThat(producerProps.get(ProducerConfig.COMPRESSION_TYPE_CONFIG))
-				.isEqualTo("gzip");
-		assertThat(producerProps.get(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG))
+		assertThat(configs.get(ProducerConfig.BUFFER_MEMORY_CONFIG)).isEqualTo(12345L);
+		assertThat(configs.get(ProducerConfig.COMPRESSION_TYPE_CONFIG)).isEqualTo("gzip");
+		assertThat(configs.get(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG))
 				.isEqualTo(LongSerializer.class);
-		assertThat(producerProps.get(SslConfigs.SSL_KEY_PASSWORD_CONFIG)).isEqualTo("p4");
-		assertThat((String) producerProps.get(SslConfigs.SSL_KEYSTORE_LOCATION_CONFIG))
+		assertThat(configs.get(SslConfigs.SSL_KEY_PASSWORD_CONFIG)).isEqualTo("p4");
+		assertThat((String) configs.get(SslConfigs.SSL_KEYSTORE_LOCATION_CONFIG))
 				.endsWith(File.separator + "ksLocP");
-		assertThat(producerProps.get(SslConfigs.SSL_KEYSTORE_PASSWORD_CONFIG))
-				.isEqualTo("p5");
-		assertThat((String) producerProps.get(SslConfigs.SSL_TRUSTSTORE_LOCATION_CONFIG))
+		assertThat(configs.get(SslConfigs.SSL_KEYSTORE_PASSWORD_CONFIG)).isEqualTo("p5");
+		assertThat((String) configs.get(SslConfigs.SSL_TRUSTSTORE_LOCATION_CONFIG))
 				.endsWith(File.separator + "tsLocP");
-		assertThat(producerProps.get(SslConfigs.SSL_TRUSTSTORE_PASSWORD_CONFIG))
+		assertThat(configs.get(SslConfigs.SSL_TRUSTSTORE_PASSWORD_CONFIG))
 				.isEqualTo("p6");
-		assertThat(producerProps.get(ProducerConfig.RETRIES_CONFIG)).isEqualTo(2);
-		assertThat(producerProps.get(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG))
+		assertThat(configs.get(ProducerConfig.RETRIES_CONFIG)).isEqualTo(2);
+		assertThat(configs.get(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG))
 				.isEqualTo(IntegerSerializer.class);
 	}
 
 	@Test
 	public void listenerProperties() {
 		load("spring.kafka.template.default-topic=testTopic",
-
 				"spring.kafka.listener.ack-mode=MANUAL",
 				"spring.kafka.listener.ack-count=123",
 				"spring.kafka.listener.ack-time=456",

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/web/ServerPropertiesTests.java

@@ -112,6 +112,14 @@ public class ServerPropertiesTests {
 		assertThat(this.properties.getServerHeader()).isEqualTo("Custom Server");
 	}
 
+	@Test
+	public void testConnectionTimeout() throws Exception {
+		Map<String, String> map = new HashMap<String, String>();
+		map.put("server.connection-timeout", "60000");
+		bindProperties(map);
+		assertThat(this.properties.getConnectionTimeout()).isEqualTo(60000);
+	}
+
 	@Test
 	public void testServletPathAsMapping() throws Exception {
 		RelaxedDataBinder binder = new RelaxedDataBinder(this.properties, "server");

spring-boot-docs/src/main/asciidoc/spring-boot-features.adoc

@@ -4343,6 +4343,8 @@ used to declare a corresponding queue on the RabbitMQ instance if necessary.
 You can enable retries on the `AmqpTemplate` to retry operations, for example in the event
 the broker connection is lost. Retries are disabled by default.
 
+
+
 [[boot-features-using-amqp-receiving]]
 ==== Receiving a message
 When the Rabbit infrastructure is present, any bean can be annotated with
@@ -4425,9 +4427,7 @@ reached.
 
 
 [[boot-features-kafka]]
-
 === Apache Kafka Support
-
 http://kafka.apache.org/[Apache Kafa] is supported by providing auto-configuration of the
 `spring-kafka` project.
 
@@ -4446,8 +4446,8 @@ for more of the supported options.
 
 
 
+[[boot-features-kafka-sending-a-message]]
 === Sending a Message
-
 Spring's `KafkaTemplate` is auto-configured and you can autowire them directly in your own
 beans:
 
@@ -4470,8 +4470,8 @@ public class MyBean {
 
 
 
+[[boot-features-kafka-receiving-a-message]]
 === Receiving a Message
-
 When the Apache Kafka infrastructure is present, any bean can be annotated with
 `@KafkaListener` to create a listener endpoint. If no `KafkaListenerContainerFactory`
 has been defined, a default one is configured automatically with keys defined in
@@ -4479,7 +4479,6 @@ has been defined, a default one is configured automatically with keys defined in
 
 The following component creates a listener endpoint on the `someTopic` topic:
 
-
 [source,java,indent=0]
 ----
 	@Component
@@ -4495,9 +4494,8 @@ The following component creates a listener endpoint on the `someTopic` topic:
 
 
 
-[[kafka-extra-props]]
+[[boot-features-kafka-extra-props]]
 === Additional Kafka Properties
-
 The properties supported by auto configuration are shown in
 <<common-application-properties>>. Note that these properties (hyphenated or camelCase)
 map directly to the Apache Kafka dotted properties for the most part, refer to the Apache
@@ -4586,6 +4584,8 @@ Lastly, the most extreme (and rarely used) option is to create your own
 `RestTemplateBuilder` bean. This will switch off the auto-configuration of a
 `RestTemplateBuilder` and will prevent any `RestTemplateCustomizer` beans from being used.
 
+
+
 [[boot-features-email]]
 == Sending email
 The Spring Framework provides an easy abstraction for sending email using the

spring-boot-samples/spring-boot-sample-tomcat/src/main/resources/application.properties

 server.compression.enabled: true
 server.compression.min-response-size: 1
+server.connection-timeout=5000

spring-boot-samples/spring-boot-sample-tomcat/src/test/java/sample/tomcat/SampleTomcatApplicationTests.java

@@ -20,13 +20,18 @@ import java.io.ByteArrayInputStream;
 import java.nio.charset.Charset;
 import java.util.zip.GZIPInputStream;
 
+import org.apache.coyote.AbstractProtocol;
+import org.apache.coyote.ProtocolHandler;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.context.embedded.EmbeddedWebApplicationContext;
+import org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedServletContainer;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
 import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.context.ApplicationContext;
 import org.springframework.http.HttpEntity;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpMethod;
@@ -52,6 +57,9 @@ public class SampleTomcatApplicationTests {
 	@Autowired
 	private TestRestTemplate restTemplate;
 
+	@Autowired
+	private ApplicationContext applicationContext;
+
 	@Test
 	public void testHome() throws Exception {
 		ResponseEntity<String> entity = this.restTemplate.getForEntity("/", String.class);
@@ -78,4 +86,15 @@ public class SampleTomcatApplicationTests {
 		}
 	}
 
+	@Test
+	public void testTimeout() throws Exception {
+		EmbeddedWebApplicationContext context = (EmbeddedWebApplicationContext) this.applicationContext;
+		TomcatEmbeddedServletContainer embeddedServletContainer = (TomcatEmbeddedServletContainer) context
+				.getEmbeddedServletContainer();
+		ProtocolHandler protocolHandler = embeddedServletContainer.getTomcat()
+				.getConnector().getProtocolHandler();
+		int timeout = ((AbstractProtocol<?>) protocolHandler).getConnectionTimeout();
+		assertThat(timeout).isEqualTo(5000);
+	}
+
 }

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

+/*
+ * 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(