Merge branch '1.4.x' into 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/web/ServerProperties.java

@@ -874,14 +874,20 @@ public class ServerProperties
 		}
 
 		private void customizeConnectionTimeout(
-				TomcatEmbeddedServletContainerFactory factory, int connectionTimeout) {
-			for (Connector connector : factory.getAdditionalTomcatConnectors()) {
+				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/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-samples/spring-boot-sample-tomcat/src/main/resources/application.properties

@@ -1,2 +1,3 @@
 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

@@ -916,14 +916,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(