root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

Polish 

Leaving out hamcrest for now, to address more broadly.

Issue: SPR-16741
This commit is contained in:
Rossen Stoyanchev 2018-07-20 10:36:57 -04:00
parent 2734f01067
commit 0c62d6b5da
5 changed files with 117 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
spring-test/src/main/java/org/springframework/test/web/reactive/server/DefaultWebTestClient.java
View File

@ -497,13 +497,8 @@ class DefaultWebTestClient implements WebTestClient {
}
@Override
public XpathAssertions xpath(String expression, Map<String, String> namespaces, Object... args) {
try {
return new XpathAssertions(this, expression, namespaces, args);
}
catch (XPathExpressionException ex) {
throw new AssertionError("XML parsing error", ex);
}
public XpathAssertions xpath(String expression, @Nullable Map<String, String> namespaces, Object... args) {
return new XpathAssertions(this, expression, namespaces, args);
}
private String getBodyAsString() {

26
spring-test/src/main/java/org/springframework/test/web/reactive/server/WebTestClient.java
View File

@ -36,6 +36,7 @@ import org.springframework.http.MediaType;
import org.springframework.http.client.reactive.ClientHttpConnector;
import org.springframework.http.client.reactive.ClientHttpRequest;
import org.springframework.http.codec.ServerCodecConfigurer;
import org.springframework.lang.Nullable;
import org.springframework.util.MultiValueMap;
import org.springframework.validation.Validator;
import org.springframework.web.reactive.accept.RequestedContentTypeResolverBuilder;
@ -820,10 +821,15 @@ public interface WebTestClient {
BodyContentSpec json(String expectedJson);
/**
* Parse the expected and actual response content as XML and perform a
* comparison verifying the same structure.
* Parse expected and actual response content as XML and assert that
* the two are "similar", i.e. they contain the same elements and
* attributes regardless of order.
* <p>Use of this method requires the
* <a href="https://github.com/xmlunit/xmlunit">XMLUnit</a> library on
* the classpath.
* @param expectedXml the expected JSON content.
* @since 5.1
* @see org.springframework.test.util.XmlExpectationsHelper#assertXmlEqual(String, String)
*/
BodyContentSpec xml(String expectedXml);
@ -839,11 +845,11 @@ public interface WebTestClient {
JsonPathAssertions jsonPath(String expression, Object... args);
/**
* Access to response body assertions using an XPath expression to inspect a specific
* subset of the body.
* Access to response body assertions using an XPath expression to
* inspect a specific subset of the body.
* <p>The XPath expression can be a parameterized string using
* formatting specifiers as defined in {@link String#format}.
* @param expression The XPath expression
* @param expression the XPath expression
* @param args arguments to parameterize the expression
* @see #xpath(String, Map, Object...)
* @since 5.1
@ -853,16 +859,16 @@ public interface WebTestClient {
}
/**
* Access to response body assertions with specific namespaces using an XPath
* expression to inspect a specific subset of the body.
* Access to response body assertions with specific namespaces using an
* XPath expression to inspect a specific subset of the body.
* <p>The XPath expression can be a parameterized string using
* formatting specifiers as defined in {@link String#format}.
* @param expression The XPath expression
* @param namespaces The namespaces
* @param expression the XPath expression
* @param namespaces namespaces to use
* @param args arguments to parameterize the expression
* @since 5.1
*/
XpathAssertions xpath(String expression, Map<String, String> namespaces, Object... args);
XpathAssertions xpath(String expression, @Nullable Map<String, String> namespaces, Object... args);
/**
* Assert the response body content with the given {@link Consumer}.

117
spring-test/src/main/java/org/springframework/test/web/reactive/server/XpathAssertions.java
View File

@ -21,18 +21,18 @@ import java.util.Map;
import java.util.Optional;
import javax.xml.xpath.XPathExpressionException;
import org.hamcrest.Matcher;
import org.w3c.dom.Node;
import org.springframework.http.HttpHeaders;
import org.springframework.lang.Nullable;
import org.springframework.test.util.XpathExpectationsHelper;
import org.springframework.util.Assert;
import org.springframework.util.MimeType;
/**
* XPath assertions for a {@link WebTestClient}.
* XPath assertions for the {@link WebTestClient}.
*
* @author Eric Deandrea
* @author Rossen Stoyanchev
* @since 5.1
*/
public class XpathAssertions {
@ -41,96 +41,87 @@ public class XpathAssertions {
private final XpathExpectationsHelper xpathHelper;
XpathAssertions(WebTestClient.BodyContentSpec spec, String expression, @Nullable Map<String, String> namespaces, Object... args) throws XPathExpressionException {
XpathAssertions(WebTestClient.BodyContentSpec spec,
String expression, @Nullable Map<String, String> namespaces, Object... args) {
this.bodySpec = spec;
this.xpathHelper = new XpathExpectationsHelper(expression, namespaces, args);
this.xpathHelper = initXpathHelper(expression, namespaces, args);
}
private static XpathExpectationsHelper initXpathHelper(
String expression, @Nullable Map<String, String> namespaces, Object[] args) {
try {
return new XpathExpectationsHelper(expression, namespaces, args);
}
catch (XPathExpressionException ex) {
throw new AssertionError("XML parsing error", ex);
}
}
/**
* Applies {@link XpathExpectationsHelper#assertString(byte[], String, String)}
* Delegates to {@link XpathExpectationsHelper#assertString(byte[], String, String)}
*/
public WebTestClient.BodyContentSpec isEqualTo(String expectedValue) {
return performXmlAssertionAndHandleError(() -> this.xpathHelper.assertString(getResponseBody(), getDefinedEncoding(), expectedValue));
return assertWith(() -> this.xpathHelper.assertString(getContent(), getCharset(), expectedValue));
}
/**
* Applies {@link XpathExpectationsHelper#assertNumber(byte[], String, Double)}
* Delegates to {@link XpathExpectationsHelper#assertNumber(byte[], String, Double)}
*/
public WebTestClient.BodyContentSpec isEqualTo(Double expectedValue) {
return performXmlAssertionAndHandleError(() -> this.xpathHelper.assertNumber(getResponseBody(), getDefinedEncoding(), expectedValue));
return assertWith(() -> this.xpathHelper.assertNumber(getContent(), getCharset(), expectedValue));
}
/**
* Applies {@link XpathExpectationsHelper#assertBoolean(byte[], String, boolean)}
* Delegates to {@link XpathExpectationsHelper#assertBoolean(byte[], String, boolean)}
*/
public WebTestClient.BodyContentSpec isEqualTo(boolean expectedValue) {
return performXmlAssertionAndHandleError(() -> this.xpathHelper.assertBoolean(getResponseBody(), getDefinedEncoding(), expectedValue));
return assertWith(() -> this.xpathHelper.assertBoolean(getContent(), getCharset(), expectedValue));
}
/**
* Applies {@link XpathExpectationsHelper#exists(byte[], String)}
* Delegates to {@link XpathExpectationsHelper#exists(byte[], String)}
*/
public WebTestClient.BodyContentSpec exists() {
return performXmlAssertionAndHandleError(() -> this.xpathHelper.exists(getResponseBody(), getDefinedEncoding()));
return assertWith(() -> this.xpathHelper.exists(getContent(), getCharset()));
}
/**
* Applies {@link XpathExpectationsHelper#doesNotExist(byte[], String)}
* Delegates to {@link XpathExpectationsHelper#doesNotExist(byte[], String)}
*/
public WebTestClient.BodyContentSpec doesNotExist() {
return performXmlAssertionAndHandleError(() -> this.xpathHelper.doesNotExist(getResponseBody(), getDefinedEncoding()));
return assertWith(() -> this.xpathHelper.doesNotExist(getContent(), getCharset()));
}
/**
* Applies {@link XpathExpectationsHelper[#assertNodeCount(byte[], String, int)}
* Delegates to {@link XpathExpectationsHelper[#assertNodeCount(byte[], String, int)}
*/
public WebTestClient.BodyContentSpec nodeCount(int expectedCount) {
return performXmlAssertionAndHandleError(() -> this.xpathHelper.assertNodeCount(getResponseBody(), getDefinedEncoding(), expectedCount));
return assertWith(() -> this.xpathHelper.assertNodeCount(getContent(), getCharset(), expectedCount));
}
/**
* Applies {@link XpathExpectationsHelper#assertNodeCount(byte[], String, Matcher)}
*/
public WebTestClient.BodyContentSpec nodeCount(Matcher<Integer> matcher) {
return performXmlAssertionAndHandleError(() -> this.xpathHelper.assertNodeCount(getResponseBody(), getDefinedEncoding(), matcher));
}
/**
* Applies {@link XpathExpectationsHelper#assertNode(byte[], String, Matcher)}
*/
public WebTestClient.BodyContentSpec nodeMatches(Matcher<? super Node> matcher) {
return performXmlAssertionAndHandleError(() -> this.xpathHelper.assertNode(getResponseBody(), getDefinedEncoding(), matcher));
}
/**
* Applies {@link XpathExpectationsHelper#assertString(byte[], String, Matcher)}
*/
public WebTestClient.BodyContentSpec matchesString(Matcher<? super String> matcher) {
return performXmlAssertionAndHandleError(() -> this.xpathHelper.assertString(getResponseBody(), getDefinedEncoding(), matcher));
}
/**
* Applies {@link XpathExpectationsHelper#assertNumber(byte[], String, Matcher)}
*/
public WebTestClient.BodyContentSpec matchesNumber(Matcher<? super Double> matcher) {
return performXmlAssertionAndHandleError(() -> this.xpathHelper.assertNumber(getResponseBody(), getDefinedEncoding(), matcher));
}
private WebTestClient.BodyContentSpec performXmlAssertionAndHandleError(AssertionThrowingRunnable assertion) {
assertion.run();
private WebTestClient.BodyContentSpec assertWith(CheckedExceptionTask task) {
try {
task.run();
}
catch (Exception ex) {
throw new AssertionError("XML parsing error", ex);
}
return this.bodySpec;
}
private byte[] getResponseBody() {
return getResult().getResponseBody();
private byte[] getContent() {
byte[] body = this.bodySpec.returnResult().getResponseBody();
Assert.notNull(body, "Expected body content");
return body;
}
private EntityExchangeResult<byte[]> getResult() {
return this.bodySpec.returnResult();
}
private String getDefinedEncoding() {
return Optional.ofNullable(getResult())
private String getCharset() {
return Optional.of(this.bodySpec.returnResult())
.map(EntityExchangeResult::getResponseHeaders)
.map(HttpHeaders::getContentType)
.map(MimeType::getCharset)
@ -138,22 +129,14 @@ public class XpathAssertions {
.name();
}
/**
* Lets us be able to use lambda expressions that could throw checked exceptions, since
* {@link XpathExpectationsHelper} throws {@link Exception} on its methods.
*/
@FunctionalInterface
private interface AssertionThrowingRunnable extends Runnable {
void runThrows() throws Exception;
private interface CheckedExceptionTask {
void run() throws Exception;
@Override
default void run() {
try {
runThrows();
}
catch (Exception ex) {
throw new AssertionError("XML parsing error", ex);
}
}
}
}

14
spring-test/src/test/java/org/springframework/test/web/reactive/server/samples/Person.java
View File

@ -15,18 +15,30 @@
*/
package org.springframework.test.web.reactive.server.samples;
import javax.xml.bind.annotation.XmlRootElement;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
@XmlRootElement
class Person {
private final String name;
private String name;
// No-arg constructor for XML
public Person() {
}
@JsonCreator
public Person(@JsonProperty("name") String name) {
this.name = name;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}

142
spring-test/src/test/java/org/springframework/test/web/reactive/server/samples/XmlContentTests.java
View File

@ -20,24 +20,17 @@ import java.net.URI;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import javax.validation.constraints.NotNull;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlRootElement;
import org.hamcrest.Matchers;
import org.junit.Test;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.test.web.reactive.server.WebTestClient;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
@ -46,30 +39,32 @@ import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* Samples of tests using {@link WebTestClient} with serialized XML content.
* Samples of tests using {@link WebTestClient} with XML content.
*
* @author Eric Deandrea
* @since 5.1
*/
public class XmlContentTests {
private static final String PEOPLE_XML =
private static final String persons_XML =
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
+ "<people><people>"
+ "<persons>"
+ "<person><name>Jane</name></person>"
+ "<person><name>Jason</name></person>"
+ "<person><name>John</name></person>"
+ "</people></people>";
+ "</persons>";
private final WebTestClient client = WebTestClient.bindToController(new PersonController()).build();
@Test
public void xmlContent() {
this.client.get().uri("/persons")
.accept(MediaType.APPLICATION_XML)
.exchange()
.expectStatus().isOk()
.expectBody().xml(PEOPLE_XML);
.expectBody().xml(persons_XML);
}
@Test
@ -80,28 +75,12 @@ public class XmlContentTests {
.expectStatus().isOk()
.expectBody()
.xpath("/").exists()
.xpath("/people").exists()
.xpath("/people/people").exists()
.xpath("/people/people/person").exists()
.xpath("/people/people/person").nodeCount(3)
.xpath("/people/people/person[1]/name").isEqualTo("Jane")
.xpath("/people/people/person[2]/name").isEqualTo("Jason")
.xpath("/people/people/person[3]/name").isEqualTo("John");
}
@Test
public void xpathMatches() {
this.client.get().uri("/persons")
.accept(MediaType.APPLICATION_XML)
.exchange()
.expectStatus().isOk()
.expectBody()
.xpath("/").exists()
.xpath("/people").exists()
.xpath("/people/people").exists()
.xpath("/people/people/person").exists()
.xpath("/people/people/person").nodeCount(3)
.xpath("//person/name").matchesString(Matchers.startsWith("J"));
.xpath("/persons").exists()
.xpath("/persons/person").exists()
.xpath("/persons/person").nodeCount(3)
.xpath("/persons/person[1]/name").isEqualTo("Jane")
.xpath("/persons/person[2]/name").isEqualTo("Jason")
.xpath("/persons/person[3]/name").isEqualTo("John");
}
@Test
@ -116,86 +95,42 @@ public class XmlContentTests {
@Test
public void postXmlContent() {
String content =
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>" +
"<person><name>John</name></person>";
this.client.post().uri("/persons")
.contentType(MediaType.APPLICATION_XML)
.syncBody("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><person><name>John</name></person>")
.syncBody(content)
.exchange()
.expectStatus().isCreated()
.expectHeader().valueEquals(HttpHeaders.LOCATION, "/persons/John")
.expectBody().isEmpty();
}
@XmlRootElement
private static class Person {
@NotNull
private String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public Person name(String name) {
setName(name);
return this;
}
@Override
public boolean equals(Object other) {
if (this == other) {
return true;
}
if (!(other instanceof Person)) {
return false;
}
Person otherPerson = (Person) other;
return ObjectUtils.nullSafeEquals(this.name, otherPerson.name);
}
@Override
public int hashCode() {
return Person.class.hashCode();
}
@Override
public String toString() {
return "Person [name=" + this.name + "]";
}
}
@SuppressWarnings("unused")
@XmlRootElement(name="people")
@XmlRootElement(name="persons")
@XmlAccessorType(XmlAccessType.FIELD)
private static class PeopleWrapper {
private static class PersonsWrapper {
@XmlElementWrapper(name="people")
@XmlElement(name="person")
private final List<Person> people = new ArrayList<>();
private final List<Person> persons = new ArrayList<>();
public PeopleWrapper() {
public PersonsWrapper() {
}
public PeopleWrapper(List<Person> people) {
this.people.addAll(people);
public PersonsWrapper(List<Person> persons) {
this.persons.addAll(persons);
}
public PeopleWrapper(Person... people) {
this.people.addAll(Arrays.asList(people));
public PersonsWrapper(Person... persons) {
this.persons.addAll(Arrays.asList(persons));
}
public List<Person> getPeople() {
return this.people;
public List<Person> getpersons() {
return this.persons;
}
}
@ -204,24 +139,19 @@ public class XmlContentTests {
static class PersonController {
@GetMapping(produces = MediaType.APPLICATION_XML_VALUE)
Mono<PeopleWrapper> getPersons() {
return Mono.just(new PeopleWrapper(new Person("Jane"), new Person("Jason"), new Person("John")));
PersonsWrapper getPersons() {
return new PersonsWrapper(new Person("Jane"), new Person("Jason"), new Person("John"));
}
@GetMapping(path = "/{name}", produces = MediaType.APPLICATION_XML_VALUE)
Mono<Person> getPerson(@PathVariable String name) {
return Mono.just(new Person(name));
Person getPerson(@PathVariable String name) {
return new Person(name);
}
@PostMapping(consumes = MediaType.APPLICATION_XML_VALUE)
Mono<ResponseEntity<Object>> savePeople(@RequestBody Flux<Person> person) {
return person
.map(Person::getName)
.map(name -> String.format("/persons/%s", name))
.map(URI::create)
.map(ResponseEntity::created)
.map(ResponseEntity.BodyBuilder::build)
.next();
ResponseEntity<Object> savepersons(@RequestBody Person person) {
URI location = URI.create(String.format("/persons/%s", person.getName()));
return ResponseEntity.created(location).build();
}
}