MockRestRequestMatchers can match query params

Issue: SPR-14995

Author: rstoyanchev

spring-test/src/main/java/org/springframework/test/web/client/match/MockRestRequestMatchers.java

@@ -24,16 +24,19 @@
 
 import org.hamcrest.Matcher;
 
-import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpMethod;
 import org.springframework.http.client.ClientHttpRequest;
 import org.springframework.test.util.AssertionErrors;
 import org.springframework.test.web.client.MockRestServiceServer;
 import org.springframework.test.web.client.RequestMatcher;
 import org.springframework.util.Assert;
+import org.springframework.util.MultiValueMap;
+import org.springframework.web.util.UriComponentsBuilder;
 
-import static org.hamcrest.MatcherAssert.*;
-import static org.springframework.test.util.AssertionErrors.*;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertNotNull;
+import static org.springframework.test.util.AssertionErrors.assertEquals;
+import static org.springframework.test.util.AssertionErrors.assertTrue;
 
 /**
  * Static factory methods for {@link RequestMatcher} classes. Typically used to
@@ -60,6 +63,21 @@ public void match(ClientHttpRequest request) throws AssertionError {
 		};
 	}
 
+	/**
+	 * Assert the {@link HttpMethod} of the request.
+	 * @param method the HTTP method
+	 * @return the request matcher
+	 */
+	public static RequestMatcher method(final HttpMethod method) {
+		Assert.notNull(method, "'method' must not be null");
+		return new RequestMatcher() {
+			@Override
+			public void match(ClientHttpRequest request) throws AssertionError {
+				AssertionErrors.assertEquals("Unexpected HttpMethod", method, request.getMethod());
+			}
+		};
+	}
+
 	/**
 	 * Assert the request URI string with the given matcher.
 	 * @param matcher String matcher for the expected URI
@@ -91,35 +109,69 @@ public void match(ClientHttpRequest request) throws IOException, AssertionError
 	}
 
 	/**
-	 * Assert the {@link HttpMethod} of the request.
-	 * @param method the HTTP method
+	 * Expect a request to the given URI.
+	 * @param uri the expected URI
 	 * @return the request matcher
 	 */
-	public static RequestMatcher method(final HttpMethod method) {
-		Assert.notNull(method, "'method' must not be null");
+	public static RequestMatcher requestTo(final URI uri) {
+		Assert.notNull(uri, "'uri' must not be null");
 		return new RequestMatcher() {
 			@Override
-			public void match(ClientHttpRequest request) throws AssertionError {
-				AssertionErrors.assertEquals("Unexpected HttpMethod", method, request.getMethod());
+			public void match(ClientHttpRequest request) throws IOException, AssertionError {
+				AssertionErrors.assertEquals("Unexpected request", uri, request.getURI());
 			}
 		};
 	}
 
 	/**
-	 * Expect a request to the given URI.
-	 * @param uri the expected URI
-	 * @return the request matcher
+	 * Assert request query parameter values with the given Hamcrest matcher.
 	 */
-	public static RequestMatcher requestTo(final URI uri) {
-		Assert.notNull(uri, "'uri' must not be null");
+	@SafeVarargs
+	public static RequestMatcher queryParam(final String name, final Matcher<? super String>... matchers) {
 		return new RequestMatcher() {
 			@Override
-			public void match(ClientHttpRequest request) throws IOException, AssertionError {
-				AssertionErrors.assertEquals("Unexpected request", uri, request.getURI());
+			public void match(ClientHttpRequest request) {
+				MultiValueMap<String, String> params = getQueryParams(request);
+				assertValueCount("query param", name, params, matchers.length);
+				for (int i = 0 ; i < matchers.length; i++) {
+					assertThat("Query param", params.get(name).get(i), matchers[i]);
+				}
 			}
 		};
 	}
 
+	/**
+	 * Assert request query parameter values.
+	 */
+	public static RequestMatcher queryParam(final String name, final String... expectedValues) {
+		return new RequestMatcher() {
+			@Override
+			public void match(ClientHttpRequest request) {
+				MultiValueMap<String, String> params = getQueryParams(request);
+				assertValueCount("query param", name, params, expectedValues.length);
+				for (int i = 0 ; i < expectedValues.length; i++) {
+					assertEquals("Query param + [" + name + "]", expectedValues[i], params.get(name).get(i));
+				}
+			}
+		};
+	}
+
+	private static MultiValueMap<String, String> getQueryParams(ClientHttpRequest request) {
+		return UriComponentsBuilder.fromUri(request.getURI()).build().getQueryParams();
+	}
+
+	private static void assertValueCount(String valueType, final String name,
+			MultiValueMap<String, String> map, int count) {
+
+		List<String> values = map.get(name);
+
+		String message = "Expected " + valueType + " <" + name + ">";
+		assertNotNull(message, values);
+
+		assertTrue(message + " to have at least <" + count + "> values but found " + values,
+				count <= values.size());
+	}
+
 	/**
 	 * Assert request header values with the given Hamcrest matcher.
 	 */
@@ -128,7 +180,7 @@ public static RequestMatcher header(final String name, final Matcher<? super Str
 		return new RequestMatcher() {
 			@Override
 			public void match(ClientHttpRequest request) {
-				assertHeaderValueCount(name, request.getHeaders(), matchers.length);
+				assertValueCount("header", name, request.getHeaders(), matchers.length);
 				for (int i = 0 ; i < matchers.length; i++) {
 					assertThat("Request header", request.getHeaders().get(name).get(i), matchers[i]);
 				}
@@ -143,7 +195,7 @@ public static RequestMatcher header(final String name, final String... expectedV
 		return new RequestMatcher() {
 			@Override
 			public void match(ClientHttpRequest request) {
-				assertHeaderValueCount(name, request.getHeaders(), expectedValues.length);
+				assertValueCount("header", name, request.getHeaders(), expectedValues.length);
 				for (int i = 0 ; i < expectedValues.length; i++) {
 					assertEquals("Request header + [" + name + "]",
 							expectedValues[i], request.getHeaders().get(name).get(i));
@@ -152,13 +204,6 @@ public void match(ClientHttpRequest request) {
 		};
 	}
 
-	private static void assertHeaderValueCount(final String name, HttpHeaders headers, int expectedCount) {
-		List<String> actualValues = headers.get(name);
-		AssertionErrors.assertTrue("Expected header <" + name + ">", actualValues != null);
-		AssertionErrors.assertTrue("Expected header <" + name + "> to have at least <" + expectedCount +
-				"> values but found " + actualValues, expectedCount <= actualValues.size());
-	}
-
 	/**
 	 * Access to request body matchers.
 	 */

spring-test/src/test/java/org/springframework/test/web/client/match/MockRestRequestMatchersTests.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.
@@ -18,6 +18,7 @@
 
 import java.net.URI;
 import java.util.Arrays;
+import java.util.Collections;
 
 import org.junit.Test;
 
@@ -124,9 +125,39 @@ public void headersWithMissingHeader() throws Exception {
 
 	@Test(expected = AssertionError.class)
 	public void headersWithMissingValue() throws Exception {
-		this.request.getHeaders().put("foo", Arrays.asList("bar"));
+		this.request.getHeaders().put("foo", Collections.singletonList("bar"));
 
 		MockRestRequestMatchers.header("foo", "bar", "baz").match(this.request);
 	}
 
+	@Test
+	public void queryParam() throws Exception {
+		this.request.setURI(new URI("http://foo.com/a?foo=bar&foo=baz"));
+		MockRestRequestMatchers.queryParam("foo", "bar", "baz").match(this.request);
+	}
+
+	@Test(expected = AssertionError.class)
+	public void queryParamMissing() throws Exception {
+		this.request.setURI(new URI("http://foo.com/a"));
+		MockRestRequestMatchers.queryParam("foo", "bar").match(this.request);
+	}
+
+	@Test(expected = AssertionError.class)
+	public void queryParamMissingValue() throws Exception {
+		this.request.setURI(new URI("http://foo.com/a?foo=bar&foo=baz"));
+		MockRestRequestMatchers.queryParam("foo", "bad").match(this.request);
+	}
+
+	@Test
+	public void queryParamContains() throws Exception {
+		this.request.setURI(new URI("http://foo.com/a?foo=bar&foo=baz"));
+		MockRestRequestMatchers.queryParam("foo", containsString("ba")).match(this.request);
+	}
+
+	@Test(expected = AssertionError.class)
+	public void queryParamContainsWithMissingValue() throws Exception {
+		this.request.setURI(new URI("http://foo.com/a?foo=bar&foo=baz"));
+		MockRestRequestMatchers.queryParam("foo", containsString("bx")).match(this.request);
+	}
+
 }