Merge pull request #1009 from rwinch/SPR-14066

Author: rstoyanchev

spring-test/src/main/java/org/springframework/test/web/servlet/htmlunit/DelegatingWebConnection.java

@@ -37,8 +37,7 @@
  * WebClient webClient = new WebClient();
  *
  * MockMvc mockMvc = ...
- * MockMvcWebConnection mockConnection = new MockMvcWebConnection(mockMvc);
- * mockConnection.setWebClient(webClient);
+ * MockMvcWebConnection mockConnection = new MockMvcWebConnection(mockMvc, webClient);
  *
  * WebRequestMatcher cdnMatcher = new UrlRegexRequestMatcher(".*?//code.jquery.com/.*");
  * WebConnection httpConnection = new HttpWebConnection(webClient);

spring-test/src/main/java/org/springframework/test/web/servlet/htmlunit/MockMvcWebClientBuilder.java

@@ -106,7 +106,7 @@ public static MockMvcWebClientBuilder webAppContextSetup(WebApplicationContext c
 	 */
 	public MockMvcWebClientBuilder withDelegate(WebClient webClient) {
 		Assert.notNull(webClient, "WebClient must not be null");
-		webClient.setWebConnection(createConnection(webClient.getWebConnection()));
+		webClient.setWebConnection(createConnection(webClient));
 		this.webClient = webClient;
 		return this;
 	}

spring-test/src/main/java/org/springframework/test/web/servlet/htmlunit/MockMvcWebConnection.java

@@ -63,16 +63,16 @@ public final class MockMvcWebConnection implements WebConnection {
 
 	private WebClient webClient;
 
-
 	/**
 	 * Create a new instance that assumes the context path of the application
 	 * is {@code ""} (i.e., the root context).
 	 * <p>For example, the URL {@code http://localhost/test/this} would use
 	 * {@code ""} as the context path.
 	 * @param mockMvc the {@code MockMvc} instance to use; never {@code null}
+	 * @param webClient the {@link WebClient} to use. never {@code null}
 	 */
-	public MockMvcWebConnection(MockMvc mockMvc) {
-		this(mockMvc, "");
+	public MockMvcWebConnection(MockMvc mockMvc, WebClient webClient) {
+		this(mockMvc, webClient, "");
 	}
 
 	/**
@@ -83,17 +83,47 @@ public MockMvcWebConnection(MockMvc mockMvc) {
 	 * which states that it can be an empty string and otherwise must start
 	 * with a "/" character and not end with a "/" character.
 	 * @param mockMvc the {@code MockMvc} instance to use; never {@code null}
+	 * @param webClient  the {@link WebClient} to use. never {@code null}
 	 * @param contextPath the contextPath to use
 	 */
-	public MockMvcWebConnection(MockMvc mockMvc, String contextPath) {
+	public MockMvcWebConnection(MockMvc mockMvc, WebClient webClient, String contextPath) {
 		Assert.notNull(mockMvc, "MockMvc must not be null");
+		Assert.notNull(webClient, "WebClient must not be null");
 		validateContextPath(contextPath);
 
-		this.webClient = new WebClient();
+		this.webClient = webClient;
 		this.mockMvc = mockMvc;
 		this.contextPath = contextPath;
 	}
 
+	/**
+	 * Create a new instance that assumes the context path of the application
+	 * is {@code ""} (i.e., the root context).
+	 * <p>For example, the URL {@code http://localhost/test/this} would use
+	 * {@code ""} as the context path.
+	 * @param mockMvc the {@code MockMvc} instance to use; never {@code null}
+	 * @deprecated Use {@link #MockMvcWebConnection(MockMvc, WebClient)}
+	 */
+	@Deprecated
+	public MockMvcWebConnection(MockMvc mockMvc) {
+		this(mockMvc, "");
+	}
+
+	/**
+	 * Create a new instance with the specified context path.
+	 * <p>The path may be {@code null} in which case the first path segment
+	 * of the URL is turned into the contextPath. Otherwise it must conform
+	 * to {@link javax.servlet.http.HttpServletRequest#getContextPath()}
+	 * which states that it can be an empty string and otherwise must start
+	 * with a "/" character and not end with a "/" character.
+	 * @param mockMvc the {@code MockMvc} instance to use; never {@code null}
+	 * @param contextPath the contextPath to use
+	 * @deprecated use {@link #MockMvcWebConnection(MockMvc, WebClient, String)}
+	 */
+	@Deprecated
+	public MockMvcWebConnection(MockMvc mockMvc, String contextPath) {
+		this(mockMvc, new WebClient(), contextPath);
+	}
 
 	public void setWebClient(WebClient webClient) {
 		Assert.notNull(webClient, "WebClient must not be null");

spring-test/src/main/java/org/springframework/test/web/servlet/htmlunit/MockMvcWebConnectionBuilderSupport.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * Copyright 2002-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
@@ -19,9 +19,11 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import com.gargoylesoftware.htmlunit.WebClient;
 import com.gargoylesoftware.htmlunit.WebConnection;
 
 import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.htmlunit.DelegatingWebConnection.DelegateWebConnection;
 import org.springframework.test.web.servlet.setup.MockMvcBuilders;
 import org.springframework.test.web.servlet.setup.MockMvcConfigurer;
 import org.springframework.util.Assert;
@@ -43,7 +45,7 @@ public abstract class MockMvcWebConnectionBuilderSupport<T extends MockMvcWebCon
 
 	private final MockMvc mockMvc;
 
-	private final List<WebRequestMatcher> mockMvcRequestMatchers = new ArrayList<WebRequestMatcher>();
+	private final List<WebRequestMatcher> requestMatchers = new ArrayList<WebRequestMatcher>();
 
 	private String contextPath = "";
 
@@ -57,7 +59,7 @@ public abstract class MockMvcWebConnectionBuilderSupport<T extends MockMvcWebCon
 	protected MockMvcWebConnectionBuilderSupport(MockMvc mockMvc) {
 		Assert.notNull(mockMvc, "MockMvc must not be null");
 		this.mockMvc = mockMvc;
-		this.mockMvcRequestMatchers.add(new HostRequestMatcher("localhost"));
+		this.requestMatchers.add(new HostRequestMatcher("localhost"));
 	}
 
 	/**
@@ -116,7 +118,7 @@ public T alwaysUseMockMvc() {
 	@SuppressWarnings("unchecked")
 	public T useMockMvc(WebRequestMatcher... matchers) {
 		for (WebRequestMatcher matcher : matchers) {
-			this.mockMvcRequestMatchers.add(matcher);
+			this.requestMatchers.add(matcher);
 		}
 		return (T) this;
 	}
@@ -130,7 +132,7 @@ public T useMockMvc(WebRequestMatcher... matchers) {
 	 */
 	@SuppressWarnings("unchecked")
 	public T useMockMvcForHosts(String... hosts) {
-		this.mockMvcRequestMatchers.add(new HostRequestMatcher(hosts));
+		this.requestMatchers.add(new HostRequestMatcher(hosts));
 		return (T) this;
 	}
 
@@ -145,21 +147,41 @@ public T useMockMvcForHosts(String... hosts) {
 	 * @see #alwaysUseMockMvc()
 	 * @see #useMockMvc(WebRequestMatcher...)
 	 * @see #useMockMvcForHosts(String...)
+	 * @deprecated Use {@link #createConnection(WebClient)} instead
 	 */
+	@Deprecated
 	protected final WebConnection createConnection(WebConnection defaultConnection) {
 		Assert.notNull(defaultConnection, "Default WebConnection must not be null");
-		MockMvcWebConnection mockMvcWebConnection = new MockMvcWebConnection(this.mockMvc, this.contextPath);
+		return createConnection(new WebClient(), defaultConnection);
+	}
+
+	/**
+	 * Create a new {@link WebConnection} that will use a {@link MockMvc}
+	 * instance if one of the specified {@link WebRequestMatcher} instances
+	 * matches.
+	 * @param webClient the WebClient to use if none of
+	 * the specified {@code WebRequestMatcher} instances matches; never {@code null}
+	 * @return a new {@code WebConnection} that will use a {@code MockMvc}
+	 * instance if one of the specified {@code WebRequestMatcher} matches
+	 * @see #alwaysUseMockMvc()
+	 * @see #useMockMvc(WebRequestMatcher...)
+	 * @see #useMockMvcForHosts(String...)
+	 * @since 4.3
+	 */
+	protected final WebConnection createConnection(WebClient webClient) {
+		Assert.notNull(webClient, "WebClient must not be null");
+		return createConnection(webClient, webClient.getWebConnection());
+	}
 
+	private WebConnection createConnection(WebClient webClient, WebConnection defaultConnection) {
+		WebConnection connection = new MockMvcWebConnection(this.mockMvc, webClient, this.contextPath);
 		if (this.alwaysUseMockMvc) {
-			return mockMvcWebConnection;
+			return connection;
 		}
-
-		List<DelegatingWebConnection.DelegateWebConnection> delegates = new ArrayList<DelegatingWebConnection.DelegateWebConnection>(
-			this.mockMvcRequestMatchers.size());
-		for (WebRequestMatcher matcher : this.mockMvcRequestMatchers) {
-			delegates.add(new DelegatingWebConnection.DelegateWebConnection(matcher, mockMvcWebConnection));
+		List<DelegateWebConnection> delegates = new ArrayList<DelegateWebConnection>(this.requestMatchers.size());
+		for (WebRequestMatcher matcher : this.requestMatchers) {
+			delegates.add(new DelegateWebConnection(matcher, connection));
 		}
-
 		return new DelegatingWebConnection(defaultConnection, delegates);
 	}
 

spring-test/src/main/java/org/springframework/test/web/servlet/htmlunit/webdriver/MockMvcHtmlUnitDriverBuilder.java

@@ -129,7 +129,7 @@ public MockMvcHtmlUnitDriverBuilder javascriptEnabled(boolean javascriptEnabled)
 	public MockMvcHtmlUnitDriverBuilder withDelegate(WebConnectionHtmlUnitDriver driver) {
 		Assert.notNull(driver, "HtmlUnitDriver must not be null");
 		driver.setJavascriptEnabled(this.javascriptEnabled);
-		driver.setWebConnection(createConnection(driver.getWebConnection()));
+		driver.setWebConnection(createConnection(driver.getWebClient()));
 		this.driver = driver;
 		return this;
 	}

spring-test/src/main/java/org/springframework/test/web/servlet/htmlunit/webdriver/WebConnectionHtmlUnitDriver.java

@@ -41,7 +41,6 @@ public class WebConnectionHtmlUnitDriver extends HtmlUnitDriver {
 
 	private WebClient webClient;
 
-
 	public WebConnectionHtmlUnitDriver(BrowserVersion browserVersion) {
 		super(browserVersion);
 	}
@@ -107,4 +106,11 @@ public void setWebConnection(WebConnection webConnection) {
 		this.webClient.setWebConnection(webConnection);
 	}
 
+	/**
+	 * Gets the current {@link WebClient}
+	 * @return the current {@link WebClient}
+	 */
+	public WebClient getWebClient() {
+		return this.webClient;
+	}
 }

spring-test/src/test/java/org/springframework/test/web/servlet/htmlunit/MockMvcConnectionBuilderSupportTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * Copyright 2002-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.
@@ -20,6 +20,10 @@
 import java.net.URL;
 import javax.servlet.http.HttpServletRequest;
 
+import com.gargoylesoftware.htmlunit.WebClient;
+import com.gargoylesoftware.htmlunit.WebConnection;
+import com.gargoylesoftware.htmlunit.WebRequest;
+import com.gargoylesoftware.htmlunit.WebResponse;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -36,121 +40,112 @@
 import org.springframework.web.context.WebApplicationContext;
 import org.springframework.web.servlet.config.annotation.EnableWebMvc;
 
-import com.gargoylesoftware.htmlunit.WebConnection;
-import com.gargoylesoftware.htmlunit.WebRequest;
-import com.gargoylesoftware.htmlunit.WebResponse;
-
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.nullValue;
 import static org.hamcrest.Matchers.notNullValue;
 import static org.junit.Assert.assertThat;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 /**
  * Integration tests for {@link MockMvcWebConnectionBuilderSupport}.
  *
  * @author Rob Winch
+ * @author Rossen Stoyanchev
  * @since 4.2
  */
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration
 @WebAppConfiguration
-@SuppressWarnings("rawtypes")
 public class MockMvcConnectionBuilderSupportTests {
 
-	private final WebConnection delegateConnection = mock(WebConnection.class);
-
 	@Autowired
 	private WebApplicationContext wac;
 
-	private MockMvc mockMvc;
+	private WebClient client;
+
+	private MockMvcWebConnectionBuilderSupport builder;
 
-	private WebConnection connection;
 
 	@Before
 	public void setup() {
-		mockMvc = MockMvcBuilders.webAppContextSetup(wac).build();
-
-		connection = new MockMvcWebConnectionBuilderSupport(mockMvc){}
-				.createConnection(delegateConnection);
+		this.client = mock(WebClient.class);
+		when(this.client.getWebConnection()).thenReturn(mock(WebConnection.class));
+		this.builder = new MockMvcWebConnectionBuilderSupport(this.wac) {};
 	}
 
+
 	@Test(expected = IllegalArgumentException.class)
 	public void constructorMockMvcNull() {
-		new MockMvcWebConnectionBuilderSupport((MockMvc)null){};
+		new MockMvcWebConnectionBuilderSupport((MockMvc) null){};
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void constructorContextNull() {
-		new MockMvcWebConnectionBuilderSupport((WebApplicationContext)null){};
+		new MockMvcWebConnectionBuilderSupport((WebApplicationContext) null){};
 	}
 
 	@Test
 	public void context() throws Exception {
-		connection = new MockMvcWebConnectionBuilderSupport(wac) {}
-				.createConnection(delegateConnection);
+		WebConnection conn = this.builder.createConnection(this.client);
 
-		assertMvcProcessed("http://localhost/");
-		assertDelegateProcessed("http://example.com/");
+		assertMockMvcUsed(conn, "http://localhost/");
+		assertMockMvcNotUsed(conn, "http://example.com/");
 	}
 
 	@Test
 	public void mockMvc() throws Exception {
-		assertMvcProcessed("http://localhost/");
-		assertDelegateProcessed("http://example.com/");
+		MockMvc mockMvc = MockMvcBuilders.webAppContextSetup(wac).build();
+		WebConnection conn = new MockMvcWebConnectionBuilderSupport(mockMvc) {}.createConnection(this.client);
+
+		assertMockMvcUsed(conn, "http://localhost/");
+		assertMockMvcNotUsed(conn, "http://example.com/");
 	}
 
 	@Test
 	public void mockMvcExampleDotCom() throws Exception {
-		connection = new MockMvcWebConnectionBuilderSupport(wac) {}
-				.useMockMvcForHosts("example.com")
-				.createConnection(delegateConnection);
+		WebConnection conn = this.builder.useMockMvcForHosts("example.com").createConnection(this.client);
 
-		assertMvcProcessed("http://localhost/");
-		assertMvcProcessed("http://example.com/");
-		assertDelegateProcessed("http://other.com/");
+		assertMockMvcUsed(conn, "http://localhost/");
+		assertMockMvcUsed(conn, "http://example.com/");
+		assertMockMvcNotUsed(conn, "http://other.com/");
 	}
 
 	@Test
 	public void mockMvcAlwaysUseMockMvc() throws Exception {
-		connection = new MockMvcWebConnectionBuilderSupport(wac) {}
-				.alwaysUseMockMvc()
-				.createConnection(delegateConnection);
-
-		assertMvcProcessed("http://other.com/");
+		WebConnection conn = this.builder.alwaysUseMockMvc().createConnection(this.client);
+		assertMockMvcUsed(conn, "http://other.com/");
 	}
 
 	@Test
 	public void defaultContextPathEmpty() throws Exception {
-		connection = new MockMvcWebConnectionBuilderSupport(wac) {}
-				.createConnection(delegateConnection);
-
-		assertThat(getWebResponse("http://localhost/abc").getContentAsString(), equalTo(""));
+		WebConnection conn = this.builder.createConnection(this.client);
+		assertThat(getResponse(conn, "http://localhost/abc").getContentAsString(), equalTo(""));
 	}
 
 	@Test
 	public void defaultContextPathCustom() throws Exception {
-		connection = new MockMvcWebConnectionBuilderSupport(wac) {}
-				.contextPath("/abc").createConnection(delegateConnection);
-
-		assertThat(getWebResponse("http://localhost/abc/def").getContentAsString(), equalTo("/abc"));
+		WebConnection conn = this.builder.contextPath("/abc").createConnection(this.client);
+		assertThat(getResponse(conn, "http://localhost/abc/def").getContentAsString(), equalTo("/abc"));
 	}
 
-	private void assertMvcProcessed(String url) throws Exception {
-		assertThat(getWebResponse(url), notNullValue());
+
+	private void assertMockMvcUsed(WebConnection connection, String url) throws Exception {
+		assertThat(getResponse(connection, url), notNullValue());
 	}
 
-	private void assertDelegateProcessed(String url) throws Exception {
-		assertThat(getWebResponse(url), nullValue());
+	private void assertMockMvcNotUsed(WebConnection connection, String url) throws Exception {
+		assertThat(getResponse(connection, url), nullValue());
 	}
 
-	private WebResponse getWebResponse(String url) throws IOException {
+	private WebResponse getResponse(WebConnection connection, String url) throws IOException {
 		return connection.getResponse(new WebRequest(new URL(url)));
 	}
 
 
 	@Configuration
 	@EnableWebMvc
+	@SuppressWarnings("unused")
 	static class Config {
 
 		@RestController