Merge remote-tracking branch 'origin/master' into 2.0.x

spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/archaius/ArchaiusAutoConfiguration.java

@@ -24,12 +24,21 @@ import java.util.concurrent.atomic.AtomicBoolean;
 
 import javax.annotation.PreDestroy;
 
+import com.netflix.config.AggregatedConfiguration;
+import com.netflix.config.ConcurrentCompositeConfiguration;
+import com.netflix.config.ConfigurationManager;
+import com.netflix.config.DeploymentContext;
+import com.netflix.config.DynamicProperty;
+import com.netflix.config.DynamicPropertyFactory;
+import com.netflix.config.DynamicURLConfiguration;
+
 import org.apache.commons.configuration.AbstractConfiguration;
 import org.apache.commons.configuration.ConfigurationBuilder;
 import org.apache.commons.configuration.EnvironmentConfiguration;
 import org.apache.commons.configuration.SystemConfiguration;
 import org.apache.commons.configuration.event.ConfigurationEvent;
 import org.apache.commons.configuration.event.ConfigurationListener;
+
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.actuate.condition.ConditionalOnEnabledEndpoint;
 import org.springframework.boot.actuate.endpoint.Endpoint;
@@ -46,14 +55,6 @@ import org.springframework.core.env.ConfigurableEnvironment;
 import org.springframework.core.env.Environment;
 import org.springframework.util.ReflectionUtils;
 
-import com.netflix.config.AggregatedConfiguration;
-import com.netflix.config.ConcurrentCompositeConfiguration;
-import com.netflix.config.ConfigurationManager;
-import com.netflix.config.DeploymentContext;
-import com.netflix.config.DynamicProperty;
-import com.netflix.config.DynamicPropertyFactory;
-import com.netflix.config.DynamicURLConfiguration;
-
 import static com.netflix.config.ConfigurationManager.APPLICATION_PROPERTIES;
 import static com.netflix.config.ConfigurationManager.DISABLE_DEFAULT_ENV_CONFIG;
 import static com.netflix.config.ConfigurationManager.DISABLE_DEFAULT_SYS_CONFIG;
@@ -75,8 +76,19 @@ public class ArchaiusAutoConfiguration {
 
 	private static final AtomicBoolean initialized = new AtomicBoolean(false);
 
+	@Autowired
+	private ConfigurableEnvironment env;
+
+	@Autowired(required = false)
+	private List<AbstractConfiguration> externalConfigurations = new ArrayList<>();
+
+	private static DynamicURLConfiguration defaultURLConfig;
+
 	@PreDestroy
 	public void close() {
+		if (defaultURLConfig != null) {
+			defaultURLConfig.stopLoading();
+		}
 		setStatic(ConfigurationManager.class, "instance", null);
 		setStatic(ConfigurationManager.class, "customConfigurationInstalled", false);
 		setStatic(DynamicPropertyFactory.class, "config", null);
@@ -152,8 +164,7 @@ public class ArchaiusAutoConfiguration {
 			config.addConfiguration(envConfig,
 					ConfigurableEnvironmentConfiguration.class.getSimpleName());
 
-			// below come from ConfigurationManager.createDefaultConfigInstance()
-			DynamicURLConfiguration defaultURLConfig = new DynamicURLConfiguration();
+			defaultURLConfig = new DynamicURLConfiguration();
 			try {
 				config.addConfiguration(defaultURLConfig, URL_CONFIG_NAME);
 			}

spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicy.java

@@ -18,17 +18,17 @@
 
 package org.springframework.cloud.netflix.ribbon;
 
-import java.util.ArrayList;
-import java.util.List;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryContext;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy;
-import org.springframework.cloud.client.loadbalancer.ServiceInstanceChooser;
-import org.springframework.core.env.Environment;
-import org.springframework.http.HttpMethod;
-import org.springframework.util.StringUtils;
 import com.netflix.client.config.CommonClientConfigKey;
 import com.netflix.client.config.IClientConfig;
 import com.netflix.client.config.IClientConfigKey;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryContext;
+import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy;
+import org.springframework.cloud.client.loadbalancer.ServiceInstanceChooser;
+import org.springframework.http.HttpMethod;
+import org.springframework.util.StringUtils;
+
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * {@link LoadBalancedRetryPolicy} for Ribbon clients.
@@ -60,7 +60,7 @@ public class RibbonLoadBalancedRetryPolicy implements LoadBalancedRetryPolicy {
         for(String code : retryableStatusCodesArray) {
             if(!StringUtils.isEmpty(code)) {
                 try {
-                    retryableStatusCodes.add(Integer.valueOf(code));
+                    retryableStatusCodes.add(Integer.valueOf(code.trim()));
                 } catch (NumberFormatException e) {
                     //TODO log
                 }

spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/AdhocTestSuite.java

@@ -20,11 +20,9 @@ import org.junit.Ignore;
 import org.junit.runner.RunWith;
 import org.junit.runners.Suite;
 import org.junit.runners.Suite.SuiteClasses;
-import org.springframework.cloud.netflix.feign.encoding.FeignAcceptEncodingTests;
-import org.springframework.cloud.netflix.metrics.servo.ServoMetricReaderTests;
-import org.springframework.cloud.netflix.ribbon.RibbonInterceptorTests;
-import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClientTests;
-import org.springframework.cloud.netflix.zuul.ZuulProxyConfigurationTests;
+
+import org.springframework.cloud.netflix.zuul.FormZuulServletProxyApplicationTests;
+import org.springframework.cloud.netflix.zuul.ZuulProxyAutoConfigurationTests;
 
 /**
  * A test suite for probing weird ordering problems in the tests.
@@ -32,8 +30,8 @@ import org.springframework.cloud.netflix.zuul.ZuulProxyConfigurationTests;
  * @author Dave Syer
  */
 @RunWith(Suite.class)
-@SuiteClasses({ RibbonLoadBalancerClientTests.class, RibbonInterceptorTests.class, FeignAcceptEncodingTests.class,
-	ServoMetricReaderTests.class, ZuulProxyConfigurationTests.class })
+@SuiteClasses({ ZuulProxyAutoConfigurationTests.class,
+		FormZuulServletProxyApplicationTests.class })
 @Ignore
 public class AdhocTestSuite {
 

spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/feign/encoding/FeignAcceptEncodingTests.java

@@ -16,14 +16,16 @@
 
 package org.springframework.cloud.netflix.feign.encoding;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
 import java.util.Collections;
 import java.util.List;
 
+import com.netflix.loadbalancer.BaseLoadBalancer;
+import com.netflix.loadbalancer.ILoadBalancer;
+import com.netflix.loadbalancer.Server;
+
 import org.junit.Test;
 import org.junit.runner.RunWith;
+
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
@@ -37,11 +39,11 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
-import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.context.junit4.SpringRunner;
 
-import com.netflix.loadbalancer.BaseLoadBalancer;
-import com.netflix.loadbalancer.ILoadBalancer;
-import com.netflix.loadbalancer.Server;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
 
 /**
  * Tests the response compression.
@@ -50,7 +52,8 @@ import com.netflix.loadbalancer.Server;
  */
 @SpringBootTest(classes = FeignAcceptEncodingTests.Application.class, webEnvironment = WebEnvironment.RANDOM_PORT, value = {
 		"feign.compression.response.enabled=true" })
-@RunWith(SpringJUnit4ClassRunner.class)
+@RunWith(SpringRunner.class)
+@DirtiesContext
 public class FeignAcceptEncodingTests {
 
 	@Autowired

spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonDisabledTests.java

@@ -19,6 +19,7 @@ package org.springframework.cloud.netflix.ribbon;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;
+
 import org.springframework.boot.builder.SpringApplicationBuilder;
 import org.springframework.cloud.test.ClassPathExclusions;
 import org.springframework.cloud.test.ModifiedClassPathRunner;
@@ -27,12 +28,12 @@ import org.springframework.cloud.test.ModifiedClassPathRunner;
  * @author Ryan Baxter
  */
 @RunWith(ModifiedClassPathRunner.class)
-@ClassPathExclusions({"ribbon-{version:\\d.*}.jar"})
+@ClassPathExclusions( {"ribbon-{version:\\d.*}.jar"} )
 public class RibbonDisabledTests {
 
 	@Test(expected = ArrayStoreException.class)
 	public void testRibbonDisabled() {
-		new SpringApplicationBuilder().web(false)
-				.sources(RibbonAutoConfiguration.class).run();
+		new SpringApplicationBuilder().web(false).sources(RibbonAutoConfiguration.class)
+				.run().close();
 	}
 }

spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactoryTest.java

@@ -201,7 +201,7 @@ public class RibbonLoadBalancedRetryPolicyFactoryTest {
     }
 
     @Test
-    public void testRetryableStatusCodest() throws Exception {
+    public void testRetryableStatusCodes() throws Exception {
         int sameServer = 3;
         int nextServer = 3;
         RibbonServer server = getRibbonServer();
@@ -210,7 +210,7 @@ public class RibbonLoadBalancedRetryPolicyFactoryTest {
         doReturn(nextServer).when(config).get(eq(CommonClientConfigKey.MaxAutoRetriesNextServer), anyInt());
         doReturn(false).when(config).get(eq(CommonClientConfigKey.OkToRetryOnAllOperations), eq(false));
         doReturn(config).when(clientFactory).getClientConfig(eq(server.getServiceId()));
-        doReturn("404,502,foo, ,").when(config).getPropertyAsString(eq(RibbonLoadBalancedRetryPolicy.RETRYABLE_STATUS_CODES),eq(""));
+        doReturn("404, 418,502,foo, ,").when(config).getPropertyAsString(eq(RibbonLoadBalancedRetryPolicy.RETRYABLE_STATUS_CODES),eq(""));
         clientFactory.getLoadBalancerContext(server.getServiceId()).setRetryHandler(new DefaultLoadBalancerRetryHandler(config));
         RibbonLoadBalancerClient client = getRibbonLoadBalancerClient(server);
         RibbonLoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
@@ -219,6 +219,7 @@ public class RibbonLoadBalancedRetryPolicyFactoryTest {
         doReturn(HttpMethod.GET).when(request).getMethod();
         assertThat(policy.retryableStatusCode(400), is(false));
         assertThat(policy.retryableStatusCode(404), is(true));
+        assertThat(policy.retryableStatusCode(418), is(true));
         assertThat(policy.retryableStatusCode(502), is(true));
     }
 

spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/zuul/RetryableZuulProxyApplicationTests.java

@@ -60,7 +60,8 @@ import com.netflix.zuul.context.RequestContext;
 		value = {
 				"zuul.routes.simple.path: /simple/**",
 				"zuul.routes.simple.retryable: true",
-				"ribbon.OkToRetryOnAllOperations: true"})
+				"ribbon.OkToRetryOnAllOperations: true",
+				"simple.ribbon.retryableStatusCodes: 404"})
 @DirtiesContext
 public class RetryableZuulProxyApplicationTests {
 
@@ -88,7 +89,7 @@ public class RetryableZuulProxyApplicationTests {
 		HttpHeaders headers = new HttpHeaders();
 		headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
 		ResponseEntity<String> result = testRestTemplate.exchange(
-				"/simple", HttpMethod.POST,
+				"/simple/poster", HttpMethod.POST,
 				new HttpEntity<>(form, headers), String.class);
 		assertEquals(HttpStatus.OK, result.getStatusCode());
 		assertEquals("Posted! {foo=[bar]}", result.getBody());
@@ -104,7 +105,7 @@ public class RetryableZuulProxyApplicationTests {
 @RibbonClient(name = "simple", configuration = RetryableRibbonClientConfiguration.class)
 class RetryableZuulProxyApplication {
 
-	@RequestMapping(value = "/", method = RequestMethod.POST)
+	@RequestMapping(value = "/poster", method = RequestMethod.POST)
 	public String delete(@RequestBody MultiValueMap<String, String> form) {
 		return "Posted! " + form;
 	}

spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/zuul/ZuulProxyAutoConfigurationTests.java

@@ -19,6 +19,7 @@ package org.springframework.cloud.netflix.zuul;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;
+
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.boot.test.context.SpringBootTest;
@@ -26,6 +27,7 @@ import org.springframework.cloud.netflix.zuul.filters.CompositeRouteLocator;
 import org.springframework.cloud.netflix.zuul.filters.RouteLocator;
 import org.springframework.cloud.netflix.zuul.filters.route.RibbonRoutingFilter;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.test.annotation.DirtiesContext;
 import org.springframework.test.context.junit4.SpringRunner;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -39,24 +41,24 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 @RunWith(SpringRunner.class)
 @SpringBootTest
+@DirtiesContext
 public class ZuulProxyAutoConfigurationTests {
-	
+
 	@Autowired
 	private RouteLocator routeLocator;
-	
+
 	@Autowired(required = false)
 	private RibbonRoutingFilter ribbonRoutingFilter;
-	
+
 	@Test
 	public void testAutoConfiguredBeans() {
 		assertThat(routeLocator).isInstanceOf(CompositeRouteLocator.class);
 		assertThat(this.ribbonRoutingFilter).isNotNull();
 	}
-	
-	
+
 	@Configuration
 	@EnableAutoConfiguration
 	@EnableZuulProxy
 	static class TestConfig {
-	}	
+	}
 }

spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/zuul/filters/route/support/RibbonRetryIntegrationTestBase.java

@@ -18,10 +18,15 @@
 
 package org.springframework.cloud.netflix.zuul.filters.route.support;
 
+import com.netflix.loadbalancer.Server;
+import com.netflix.loadbalancer.ServerList;
+import com.netflix.zuul.context.RequestContext;
+
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.junit.Before;
 import org.junit.Test;
+
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.boot.test.web.client.TestRestTemplate;
@@ -47,10 +52,6 @@ import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseStatus;
 import org.springframework.web.bind.annotation.RestController;
 
-import com.netflix.loadbalancer.Server;
-import com.netflix.loadbalancer.ServerList;
-import com.netflix.zuul.context.RequestContext;
-
 import static org.junit.Assert.assertEquals;
 
 /**
@@ -67,12 +68,10 @@ public abstract class RibbonRetryIntegrationTestBase {
 	public void setup() {
 		RequestContext.getCurrentContext().clear();
 		String uri = "/resetError";
-		new TestRestTemplate().exchange(
-				"http://localhost:" + this.port + uri, HttpMethod.GET,
-				new HttpEntity<>((Void) null), String.class);
+		new TestRestTemplate().exchange("http://localhost:" + this.port + uri,
+				HttpMethod.GET, new HttpEntity<>((Void) null), String.class);
 	}
 
-
 	@Test
 	public void retryable() {
 		String uri = "/retryable/everyothererror";
@@ -147,9 +146,11 @@ public abstract class RibbonRetryIntegrationTestBase {
 			@RibbonClient(name = "retryable", configuration = RibbonClientConfiguration.class),
 			@RibbonClient(name = "disableretry", configuration = RibbonClientConfiguration.class),
 			@RibbonClient(name = "globalretrydisabled", configuration = RibbonClientConfiguration.class),
-			@RibbonClient(name = "getretryable", configuration = RibbonClientConfiguration.class)})
+			@RibbonClient(name = "getretryable", configuration = RibbonClientConfiguration.class) })
 	public static class RetryableTestConfig {
 
+		private final Log LOG = LogFactory.getLog(RetryableTestConfig.class);
+
 		private boolean error = true;
 
 		@RequestMapping("/resetError")
@@ -162,13 +163,14 @@ public abstract class RibbonRetryIntegrationTestBase {
 			boolean shouldError = error;
 			error = !error;
 			try {
-				if(shouldError) {
+				if (shouldError) {
 					Thread.sleep(80000);
 				}
-			} catch (InterruptedException e) {
-				e.printStackTrace();
 			}
-
+			catch (InterruptedException e) {
+				LOG.info(e);
+				Thread.currentThread().interrupt();
+			}
 
 			return new ResponseEntity<String>("no error", HttpStatus.OK);
 		}
@@ -183,9 +185,9 @@ public abstract class RibbonRetryIntegrationTestBase {
 		public ResponseEntity<String> fourOFourError() {
 			boolean shouldError = error;
 			error = !error;
-				if(shouldError) {
-					return new ResponseEntity<String>("not found", HttpStatus.NOT_FOUND);
-				}
+			if (shouldError) {
+				return new ResponseEntity<String>("not found", HttpStatus.NOT_FOUND);
+			}
 			return new ResponseEntity<String>("no error", HttpStatus.OK);
 		}
 
@@ -204,14 +206,17 @@ public abstract class RibbonRetryIntegrationTestBase {
 	}
 
 	@Configuration
-	public static class FourOFourRetryableRibbonConfiguration extends RibbonClientConfiguration {
+	public static class FourOFourRetryableRibbonConfiguration
+			extends RibbonClientConfiguration {
 
 		@Bean
-		public LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory(SpringClientFactory factory) {
+		public LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory(
+				SpringClientFactory factory) {
 			return new MyRibbonRetryPolicyFactory(factory);
 		}
 
-		public static class MyRibbonRetryPolicyFactory extends RibbonLoadBalancedRetryPolicyFactory {
+		public static class MyRibbonRetryPolicyFactory
+				extends RibbonLoadBalancedRetryPolicyFactory {
 
 			private SpringClientFactory factory;
 
@@ -221,21 +226,25 @@ public abstract class RibbonRetryIntegrationTestBase {
 			}
 
 			@Override
-			public LoadBalancedRetryPolicy create(String serviceId, ServiceInstanceChooser loadBalanceChooser) {
+			public LoadBalancedRetryPolicy create(String serviceId,
+					ServiceInstanceChooser loadBalanceChooser) {
 				RibbonLoadBalancerContext lbContext = this.factory
 						.getLoadBalancerContext(serviceId);
-				return new MyLoadBalancedRetryPolicy(serviceId, lbContext, loadBalanceChooser);
+				return new MyLoadBalancedRetryPolicy(serviceId, lbContext,
+						loadBalanceChooser);
 			}
 
 			class MyLoadBalancedRetryPolicy extends RibbonLoadBalancedRetryPolicy {
 
-				public MyLoadBalancedRetryPolicy(String serviceId, RibbonLoadBalancerContext context, ServiceInstanceChooser loadBalanceChooser) {
+				public MyLoadBalancedRetryPolicy(String serviceId,
+						RibbonLoadBalancerContext context,
+						ServiceInstanceChooser loadBalanceChooser) {
 					super(serviceId, context, loadBalanceChooser);
 				}
 
 				@Override
-				public boolean retryableStatusCode( int statusCode) {
-					if(statusCode == HttpStatus.NOT_FOUND.value()) {
+				public boolean retryableStatusCode(int statusCode) {
+					if (statusCode == HttpStatus.NOT_FOUND.value()) {
 						return true;
 					}
 					return super.retryableStatusCode(statusCode);

spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/zuul/filters/route/support/ZuulProxyTestBase.java

@@ -30,8 +30,16 @@ import java.util.concurrent.atomic.AtomicBoolean;
 
 import javax.servlet.http.HttpServletRequest;
 
+import com.netflix.loadbalancer.Server;
+import com.netflix.loadbalancer.ServerList;
+import com.netflix.zuul.ZuulFilter;
+import com.netflix.zuul.context.RequestContext;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
 import org.junit.Before;
 import org.junit.Test;
+
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.web.ErrorProperties;
@@ -45,6 +53,7 @@ import org.springframework.cloud.netflix.zuul.filters.ZuulProperties;
 import org.springframework.cloud.netflix.zuul.filters.discovery.DiscoveryClientRouteLocator;
 import org.springframework.cloud.netflix.zuul.filters.route.RibbonCommandFactory;
 import org.springframework.cloud.netflix.zuul.filters.route.ZuulFallbackProvider;
+import org.springframework.cloud.netflix.zuul.filters.route.support.RibbonRetryIntegrationTestBase.RetryableTestConfig;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.http.HttpEntity;
@@ -68,11 +77,6 @@ import org.springframework.web.servlet.config.annotation.DelegatingWebMvcConfigu
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
 import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
 
-import com.netflix.loadbalancer.Server;
-import com.netflix.loadbalancer.ServerList;
-import com.netflix.zuul.ZuulFilter;
-import com.netflix.zuul.context.RequestContext;
-
 import static org.hamcrest.Matchers.is;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
@@ -217,12 +221,13 @@ public abstract class ZuulProxyTestBase {
 	public void ribbonDeleteWithBody() {
 		this.endpoint.reset();
 		ResponseEntity<String> result = new TestRestTemplate().exchange(
-				"http://localhost:" + this.port + "/simple/deletewithbody", HttpMethod.DELETE,
-				new HttpEntity<>("deleterequestbody"), String.class);
+				"http://localhost:" + this.port + "/simple/deletewithbody",
+				HttpMethod.DELETE, new HttpEntity<>("deleterequestbody"), String.class);
 		assertEquals(HttpStatus.OK, result.getStatusCode());
 		if (supportsDeleteWithBody()) {
 			assertEquals("Deleted deleterequestbody", result.getBody());
-		} else {
+		}
+		else {
 			assertEquals("Deleted null", result.getBody());
 		}
 	}
@@ -289,16 +294,16 @@ public abstract class ZuulProxyTestBase {
 		assertEquals(HttpStatus.OK, result.getStatusCode());
 		assertEquals("Patched 1!", result.getBody());
 	}
-	
+
 	@SuppressWarnings("deprecation")
 	@Test
 	public void javascriptEncodedFormParams() {
 		TestRestTemplate testRestTemplate = new TestRestTemplate();
 		ArrayList<HttpMessageConverter<?>> converters = new ArrayList<>();
-		converters.addAll(Arrays.asList(new StringHttpMessageConverter(), 
+		converters.addAll(Arrays.asList(new StringHttpMessageConverter(),
 				new NoEncodingFormHttpMessageConverter()));
 		testRestTemplate.getRestTemplate().setMessageConverters(converters);
-		
+
 		MultiValueMap<String, String> map = new LinkedMultiValueMap<>();
 		map.add("foo", "(bar)");
 		ResponseEntity<String> result = testRestTemplate.postForEntity(
@@ -310,9 +315,11 @@ public abstract class ZuulProxyTestBase {
 	public static abstract class AbstractZuulProxyApplication
 			extends DelegatingWebMvcConfiguration {
 
+		private final Log LOG = LogFactory.getLog(RetryableTestConfig.class);
+
 		@RequestMapping(value = "/local/{id}", method = RequestMethod.PATCH)
 		public String patch(@PathVariable final String id,
-							@RequestBody final String body) {
+				@RequestBody final String body) {
 			return "Patched " + id + "!";
 		}
 
@@ -325,11 +332,12 @@ public abstract class ZuulProxyTestBase {
 		public String local() {
 			return "Hello local";
 		}
-		
+
 		@RequestMapping(value = "/local", method = RequestMethod.POST)
-		public String postWithFormParam(HttpServletRequest request, 
+		public String postWithFormParam(HttpServletRequest request,
 				@RequestBody MultiValueMap<String, String> body) {
-			return "Posted " + body.get("foo") + " and Content-Length was: " + request.getContentLength() + "!";
+			return "Posted " + body.get("foo") + " and Content-Length was: "
+					+ request.getContentLength() + "!";
 		}
 
 		@RequestMapping(value = "/deletewithbody", method = RequestMethod.DELETE)
@@ -374,8 +382,10 @@ public abstract class ZuulProxyTestBase {
 		public String slow() {
 			try {
 				Thread.sleep(80000);
-			} catch (InterruptedException e) {
-				e.printStackTrace();
+			}
+			catch (InterruptedException e) {
+				LOG.info(e);
+				Thread.currentThread().interrupt();
 			}
 			return "slow";
 		}
@@ -425,7 +435,6 @@ public abstract class ZuulProxyTestBase {
 			return mapping;
 		}
 
-
 	}
 
 	public static class FallbackProvider implements ZuulFallbackProvider {
@@ -472,14 +481,16 @@ public abstract class ZuulProxyTestBase {
 			};
 		}
 	}
-	
+
 	@Configuration
-	public class FormEncodedMessageConverterConfiguration extends WebMvcConfigurerAdapter {
+	public class FormEncodedMessageConverterConfiguration
+			extends WebMvcConfigurerAdapter {
 
 		@Override
 		public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
 			FormHttpMessageConverter converter = new FormHttpMessageConverter();
-			MediaType mediaType = new MediaType("application", "x-www-form-urlencoded", Charset.forName("UTF-8"));
+			MediaType mediaType = new MediaType("application", "x-www-form-urlencoded",
+					Charset.forName("UTF-8"));
 			converter.setSupportedMediaTypes(Arrays.asList(mediaType));
 			converters.add(converter);
 			super.configureMessageConverters(converters);
@@ -495,8 +506,8 @@ public abstract class ZuulProxyTestBase {
 
 		@Bean
 		public ServerList<Server> ribbonServerList() {
-														   return new StaticServerList<>(new Server("localhost", this.port));
-																															 }
+			return new StaticServerList<>(new Server("localhost", this.port));
+		}
 
 	}
 
@@ -519,12 +530,13 @@ public abstract class ZuulProxyTestBase {
 		AtomicBoolean controllerUsed = new AtomicBoolean();
 
 		public MyErrorController(ErrorAttributes errorAttributes) {
-																		super(errorAttributes, new ErrorProperties());
-																													  }
+			super(errorAttributes, new ErrorProperties());
+		}
 
 		@Override
 		public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
-			String errorUri = (String) request.getAttribute("javax.servlet.error.request_uri");
+			String errorUri = (String) request
+					.getAttribute("javax.servlet.error.request_uri");
 
 			if (errorUri != null && errorUri.equals(this.uriToMatch.get())) {
 				controllerUsed.set(true);
@@ -534,15 +546,15 @@ public abstract class ZuulProxyTestBase {
 		}
 
 		public void setUriToMatch(String uri) {
-													this.uriToMatch.set(uri);
-																			 }
+			this.uriToMatch.set(uri);
+		}
 
 		public boolean wasControllerUsed() {
-												 return this.controllerUsed.get();
-																				  }
+			return this.controllerUsed.get();
+		}
 
 		public void clear() {
-								  this.controllerUsed.set(false);
-																 }
+			this.controllerUsed.set(false);
+		}
 	}
 }