public interface ResponseSpecification
Modifier and Type | Method and Description |
---|---|
ResponseSpecification |
and()
Syntactic sugar, e.g.
|
default ResponseSpecification |
appendRoot(String pathToAppend)
Deprecated.
Use
appendRootPath(String) instead |
default ResponseSpecification |
appendRoot(String pathToAppend,
List<Argument> arguments)
Deprecated.
Use
appendRootPath(String, List) instead |
ResponseSpecification |
appendRootPath(String pathToAppend)
Append the given path to the root path of the response body so that you don't need to write the entire path for each expectation.
|
ResponseSpecification |
appendRootPath(String pathToAppend,
List<Argument> arguments)
Append the given path to the root path with arguments supplied of the response body so that you don't need to write the entire path for each expectation.
|
ResponseSpecification |
body(List<Argument> arguments,
org.hamcrest.Matcher matcher,
Object... additionalKeyMatcherPairs)
This as special kind of expectation that is mainly useful when you've specified a root path with an argument placeholder.
|
ResponseSpecification |
body(org.hamcrest.Matcher<?> matcher,
org.hamcrest.Matcher<?>... additionalMatchers)
Expect that the response body conforms to one or more Hamcrest matchers.
|
ResponseSpecification |
body(String key,
List<Argument> arguments,
org.hamcrest.Matcher matcher,
Object... additionalKeyMatcherPairs)
Same as
body(String, org.hamcrest.Matcher, Object...) expect that you can pass arguments to the key. |
ResponseSpecification |
body(String path,
org.hamcrest.Matcher<?> matcher,
Object... additionalKeyMatcherPairs)
Expect that the JSON or XML response body conforms to one or more Hamcrest matchers.
|
ResponseSpecification |
contentType(ContentType contentType)
Set the response content type to be
contentType . |
ResponseSpecification |
contentType(org.hamcrest.Matcher<? super String> contentType)
Expect the response content type to be
contentType . |
ResponseSpecification |
contentType(String contentType)
Set the response content type to be
contentType . |
ResponseSpecification |
cookie(String cookieName)
Expect that a cookie exist in the response, regardless of value (it may have no value at all).
|
ResponseSpecification |
cookie(String cookieName,
DetailedCookieMatcher detailedCookieMatcher)
Validate that a detailed response cookie matches the supplied cookie name and hamcrest matcher (see
DetailedCookieMatcher . |
ResponseSpecification |
cookie(String cookieName,
org.hamcrest.Matcher<?> expectedValueMatcher)
Expect that a response cookie matches the supplied cookie name and hamcrest matcher.
|
ResponseSpecification |
cookie(String cookieName,
Object expectedValue)
Expect that a response cookie matches the supplied name and value.
|
ResponseSpecification |
cookies(Map<String,?> expectedCookies)
Expect that response cookies matches those specified in a Map.
|
ResponseSpecification |
cookies(String firstExpectedCookieName,
Object firstExpectedCookieValue,
Object... expectedCookieNameValuePairs)
Expect that response cookies matches the supplied cookie names and values.
|
ResponseSpecification |
defaultParser(Parser parser)
Register a default predefined parser that will be used if no other parser (registered or pre-defined) matches the response
content-type.
|
default ResponseSpecification |
detachRoot(String pathToDetach)
Deprecated.
Use
detachRootPath(String) instead |
ResponseSpecification |
detachRootPath(String pathToDetach)
Detach the given path from the root path.
|
ResponseSpecification |
expect()
Syntactic sugar, e.g.
|
RequestSpecification |
given()
Returns the request io.restassured.specification so that you can define the properties of the request.
|
<T> ResponseSpecification |
header(String headerName,
java.util.function.Function<String,T> mappingFunction,
org.hamcrest.Matcher<? super T> expectedValueMatcher)
Expect that a response header matches the supplied header name and hamcrest matcher using a mapping function.
|
ResponseSpecification |
header(String headerName,
org.hamcrest.Matcher<?> expectedValueMatcher)
Expect that a response header matches the supplied header name and hamcrest matcher.
|
ResponseSpecification |
header(String headerName,
String expectedValue)
Expect that a response header matches the supplied name and value.
|
ResponseSpecification |
headers(Map<String,?> expectedHeaders)
Expect that response headers matches those specified in a Map.
|
ResponseSpecification |
headers(String firstExpectedHeaderName,
Object firstExpectedHeaderValue,
Object... expectedHeaders)
Expect that response headers matches the supplied headers and values.
|
ResponseLogSpecification |
log()
Returns the
ResponseLogSpecification that allows you to log different parts of the ResponseSpecification . |
ResponseSpecification |
logDetail(LogDetail logDetail)
Log different parts of the
ResponseSpecification by using LogDetail . |
default ResponseSpecification |
noRoot()
Deprecated.
Use
noRootPath() instead |
ResponseSpecification |
noRootPath()
Reset the root path of the response body so that you don't need to write the entire path for each expectation.
|
ResponseSpecification |
parser(String contentType,
Parser parser)
Register a content-type to be parsed using a predefined parser.
|
RequestSpecification |
request()
Returns the request io.restassured.specification so that you can define the properties of the request.
|
ResponseSpecification |
response()
Syntactic sugar, e.g.
|
default ResponseSpecification |
root(String rootPath)
Deprecated.
Use
rootPath(String) (String)} instead |
default ResponseSpecification |
root(String rootPath,
List<Argument> arguments)
Deprecated.
Use
rootPath(String, List) (String)} instead |
ResponseSpecification |
rootPath(String rootPath)
Set the root path of the response body so that you don't need to write the entire path for each expectation.
|
ResponseSpecification |
rootPath(String rootPath,
List<Argument> arguments)
Set the root path with arguments of the response body so that you don't need to write the entire path for each expectation.
|
ResponseSpecification |
spec(ResponseSpecification responseSpecificationToMerge)
Expect that the response matches an entire specification.
|
ResponseSpecification |
statusCode(int expectedStatusCode)
Expect that the response status code matches an integer.
|
ResponseSpecification |
statusCode(org.hamcrest.Matcher<? super Integer> expectedStatusCode)
Expect that the response status code matches the given Hamcrest matcher.
|
ResponseSpecification |
statusLine(org.hamcrest.Matcher<? super String> expectedStatusLine)
Expect that the response status line matches the given Hamcrest matcher.
|
ResponseSpecification |
statusLine(String expectedStatusLine)
Expect that the response status line matches the given String.
|
ResponseSpecification |
that()
Syntactic sugar, e.g.
|
ResponseSpecification |
then()
Syntactic sugar, e.g.
|
ResponseSpecification |
time(org.hamcrest.Matcher<Long> matcher)
Validate that the response time (in milliseconds) matches the supplied
matcher . |
ResponseSpecification |
time(org.hamcrest.Matcher<Long> matcher,
TimeUnit timeUnit)
Validate that the response time matches the supplied
matcher and time unit. |
Response |
validate(Response response)
Validates the specified response against this ResponseSpecification
|
RequestSender |
when()
Syntactic sugar, e.g.
|
RequestSpecification |
with()
Returns the request io.restassured.specification so that you can define the properties of the request.
|
Response validate(Response response)
response
- The response to validateResponseSpecification time(org.hamcrest.Matcher<Long> matcher)
matcher
. For example:
when(). get("/something"). then(). time(lessThan(2000L));where
lessThan
is a Hamcrest matcherValidatableResponse
instance.ResponseSpecification time(org.hamcrest.Matcher<Long> matcher, TimeUnit timeUnit)
matcher
and time unit. For example:
when(). get("/something"). then(). time(lessThan(2L), TimeUnit.SECONDS);where
lessThan
is a Hamcrest matcherValidatableResponse
instance.ResponseSpecification body(String key, List<Argument> arguments, org.hamcrest.Matcher matcher, Object... additionalKeyMatcherPairs)
body(String, org.hamcrest.Matcher, Object...)
expect that you can pass arguments to the key. This
is useful in situations where you have e.g. pre-defined variables that constitutes the key:
String someSubPath = "else"; int index = 1; when().get().then().body("something.%s[%d]", withArgs(someSubPath, index), equalTo("some value")). ..or if you have complex root paths and don't wish to duplicate the path for small variations:
when(). get() then(). rootPath("filters.filterConfig[%d].filterConfigGroups.find { it.name == 'Gold' }.includes"). body(withArgs(0), hasItem("first")). body(withArgs(1), hasItem("second")). ..The key and arguments follows the standard formatting syntax of Java.
Note that withArgs
can be statically imported from the io.restassured.RestAssured
class.
key
- The body keyarguments
- The arguments to apply to the keymatcher
- The hamcrest matcher that must response body must match.additionalKeyMatcherPairs
- Optionally additional hamcrest matchers that must return true
.body(String, org.hamcrest.Matcher, Object...)
ResponseSpecification body(List<Argument> arguments, org.hamcrest.Matcher matcher, Object... additionalKeyMatcherPairs)
when(). get(..). then(). rootPath("x.%s"). // Root path with a placeholder body(withArgs("firstName"), equalTo(..)). body(withArgs("lastName"), equalTo(..)).Note that this is the same as doing:
when(). get(..); then(). rootPath("x.%s"). // Root path with a placeholder body(withArgs("firstName"), equalTo(..)). body(withArgs("lastName"), equalTo(..)).
arguments
- The arguments to apply to the root path.matcher
- The hamcrest matcher that must response body must match.additionalKeyMatcherPairs
- Optionally additional hamcrest matchers that must return true
.body(String, org.hamcrest.Matcher, Object...)
ResponseSpecification statusCode(org.hamcrest.Matcher<? super Integer> expectedStatusCode)
expect().statusCode(equalTo(200)).when().get("/something");
expectedStatusCode
- The expected status code matcher.ResponseSpecification statusCode(int expectedStatusCode)
expect().statusCode(200).when().get("/something");This is the same as:
expect().statusCode(equalTo(200)).when().get("/something");
expectedStatusCode
- The expected status code.ResponseSpecification statusLine(org.hamcrest.Matcher<? super String> expectedStatusLine)
expect().statusLine(equalTo("No Content")).when().get("/something");
expectedStatusLine
- The expected status line matcher.ResponseSpecification statusLine(String expectedStatusLine)
expect().statusLine("No Content").when().get("/something");This is the same as:
expect().statusLine(equalTo("No Content")).when().get("/something");
expectedStatusLine
- The expected status line.ResponseSpecification headers(Map<String,?> expectedHeaders)
E.g. expect that the response of the GET request to "/something" contains header headerName1=headerValue1 and headerName2=headerValue2:
Map expectedHeaders = new HashMap(); expectedHeaders.put("headerName1", "headerValue1")); expectedHeaders.put("headerName2", "headerValue2"); expect().response().headers(expectedHeaders).when().get("/something");
You can also use Hamcrest matchers:
Map expectedHeaders = new HashMap(); expectedHeaders.put("Content-Type", containsString("charset=UTF-8")); expectedHeaders.put("Content-Length", "160"); expect().headers(expectedHeaders).when().get("/something");
expectedHeaders
- The Map of expected response headersResponseSpecification headers(String firstExpectedHeaderName, Object firstExpectedHeaderValue, Object... expectedHeaders)
E.g. expect that the response of the GET request to "/something" contains header Pragma=no-cache and Content-Encoding=gzip:
expect().headers("Pragma", "no-cache", "Content-Encoding", "gzip").when().get("/something");
You can also use Hamcrest matchers:
expect().response().headers("Content-Type", containsString("application/json"), "Pragma", equalsTo("no-cache")).when().get("/something");and you can even mix string matching and hamcrest matching:
expect().headers("Content-Type", containsString("application/json"), "Pragma", "no-cache").when().get("/something");
firstExpectedHeaderName
- The name of the first headerfirstExpectedHeaderValue
- The value of the first headerexpectedHeaders
- A list of expected "header name" - "header value" pairs.ResponseSpecification header(String headerName, org.hamcrest.Matcher<?> expectedValueMatcher)
E.g. expect that the response of the GET request to "/something" contains header Pragma=no-cache:
expect().header("Pragma", containsString("no")).when().get("/something");
You can also expect several headers:
expect().header("Pragma", equalsTo("no-cache")),and().header("Content-Encoding", containsString("zip")).when().get("/something");Also take a look at
headers(String, Object, Object...)
)} for a short version of passing multiple headers.
headerName
- The name of the expected headerexpectedValueMatcher
- The Hamcrest matcher that must conform to the value<T> ResponseSpecification header(String headerName, java.util.function.Function<String,T> mappingFunction, org.hamcrest.Matcher<? super T> expectedValueMatcher)
E.g. expect that the response of the GET request to "/something" contains header Content-Length: 500 and you want to validate that the length must always be less than 600:
when(). get("/something"). then(). header("Content-Length", Integer::parseInt, lessThan(600));
headerName
- The name of the expected headermappingFunction
- Map the header to another value type before exposing it to the Hamcrest matcherexpectedValueMatcher
- The Hamcrest matcher that must conform to the valueResponseSpecification header(String headerName, String expectedValue)
E.g. expect that the response of the GET request to "/something" contains header Pragma=no-cache:
expect().header("Pragma", "no-cache").when().get("/something");
You can also expect several headers:
expect().header("Pragma", "no-cache"),and().header("Content-Encoding", "gzip").when().get("/something");Also take a look at
headers(String, Object, Object...)
for a short version of passing multiple headers.
headerName
- The name of the expected headerexpectedValue
- The value of the expected headerResponseSpecification cookies(Map<String,?> expectedCookies)
E.g. expect that the response of the GET request to "/something" contains cookies cookieName1=cookieValue1 and cookieName2=cookieValue2:
Map expectedCookies = new HashMap(); expectedCookies.put("cookieName1", "cookieValue1")); expectedCookies.put("cookieName2", "cookieValue2"); expect().response().cookies(expectedCookies).when().get("/something");
You can also use Hamcrest matchers:
Map expectedCookies = new HashMap(); expectedCookies.put("cookieName1", containsString("Value1")); expectedCookies.put("cookieName2", "cookieValue2"); expect().cookies(expectedCookies).when().get("/something");
expectedCookies
- A Map of expected response cookiesResponseSpecification cookie(String cookieName)
cookieName
- the cookie to validate that it existsResponseSpecification cookies(String firstExpectedCookieName, Object firstExpectedCookieValue, Object... expectedCookieNameValuePairs)
E.g. expect that the response of the GET request to "/something" contains cookies cookieName1=cookieValue1 and cookieName2=cookieValue2:
expect().cookies("cookieName1", "cookieValue1", "cookieName2", "cookieValue2").when().get("/something");
You can also use Hamcrest matchers:
expect().response().cookies("cookieName1", containsString("Value1"), "cookieName2", equalsTo("cookieValue2")).when().get("/something");and you can even mix string matching and hamcrest matching:
expect().cookies("cookieName1", containsString("Value1"), "cookieName2", "cookieValue2").when().get("/something");
firstExpectedCookieName
- The name of the first cookiefirstExpectedCookieValue
- The value of the first cookieexpectedCookieNameValuePairs
- A list of expected "cookie name" - "cookie value" pairs.ResponseSpecification cookie(String cookieName, org.hamcrest.Matcher<?> expectedValueMatcher)
E.g. expect that the response of the GET request to "/something" contain cookie cookieName1=cookieValue1
expect().cookie("cookieName1", containsString("Value1")).when().get("/something");
You can also expect several cookies:
expect().cookie("cookieName1", equalsTo("cookieValue1")).and().cookie("cookieName2", containsString("Value2")).when().get("/something");Also take a look at
cookies(String, Object, Object...)
for a short version of passing multiple cookies.
cookieName
- The name of the expected cookieexpectedValueMatcher
- The Hamcrest matcher that must conform to the valueResponseSpecification cookie(String cookieName, DetailedCookieMatcher detailedCookieMatcher)
DetailedCookieMatcher
.
E.g. expect that the response of the GET request to "/something" contain cookie cookieName1=cookieValue1
expect.cookie("cookieName1", detailedCookie().value("cookieValue1").secured(true));
You can also expect several cookies:
expect().cookie("cookieName1", detailedCookie().value("cookieValue1").secured(true)) .and().cookie("cookieName2", detailedCookie().value("cookieValue2").secured(false));
cookieName
- The name of the expected cookiedetailedCookieMatcher
- The Hamcrest matcher that must conform to the cookieResponseSpecification cookie(String cookieName, Object expectedValue)
E.g. expect that the response of the GET request to "/something" contain cookie cookieName1=cookieValue1:
expect().cookie("cookieName1", "cookieValue1").when().get("/something");
You can also expect several cookies:
expect().cookie("cookieName1", "cookieValue1"),and().cookie("cookieName2", "cookieValue2").when().get("/something");Also take a look at
cookies(String, Object, Object...)
for a short version of passing multiple cookies.
cookieName
- The name of the expected cookieexpectedValue
- The value of the expected cookieResponseLogSpecification log()
ResponseLogSpecification
that allows you to log different parts of the ResponseSpecification
.
This is mainly useful for debug purposes when writing your tests. It's a shortcut for:
given().filter(ResponseLoggingFilter.responseLogger()). ..
ResponseSpecification rootPath(String rootPath, List<Argument> arguments)
rootPath
- The root path to use.arguments
- The list of substitution arguments. The path and arguments follows the standard formatting syntax of Java..@Deprecated default ResponseSpecification root(String rootPath, List<Argument> arguments)
rootPath(String, List)
(String)} insteadrootPath
- The root path to use.arguments
- The list of substitution arguments. The path and arguments follows the standard formatting syntax of Java..rootPath(String, List)
ResponseSpecification rootPath(String rootPath)
when(). get(..); then(). body("x.y.firstName", is(..)). body("x.y.lastName", is(..)). body("x.y.age", is(..)). body("x.y.gender", is(..)).you can use a root and do:
when(). get(..). then(). rootPath("x.y"). body("firstName", is(..)). body("lastName", is(..)). body("age", is(..)). body("gender", is(..)).
rootPath
- The root path to use.@Deprecated default ResponseSpecification root(String rootPath)
rootPath(String)
(String)} insteadrootPath
- The root path.rootPath(String)
ResponseSpecification noRootPath()
when(). get(..); then(). rootPath("x.y"). body("firstName", is(..)). body("lastName", is(..)). noRootPath() body("z.something1", is(..)). body("w.something2", is(..)).This is the same as calling
rootPath("")
but less verbose and the it communicates intent better.rootPath(String)
@Deprecated default ResponseSpecification noRoot()
noRootPath()
insteadResponseSpecification appendRootPath(String pathToAppend)
expect(). rootPath("x.y"). body("age", is(..)). body("gender", is(..)). body("name.firstName", is(..)). body("name.lastName", is(..)). when(). get(..);you can use a append root and do:
expect(). rootPath("x.y"). body("age", is(..)). body("gender", is(..)). appendRootPath("name"). body("firstName", is(..)). body("lastName", is(..)). when(). get(..);
pathToAppend
- The root path to append.ResponseSpecification appendRootPath(String pathToAppend, List<Argument> arguments)
String namePath = "name"; expect(). rootPath("x.y"). body("age", is(..)). body("gender", is(..)). body(namePath + "first", is(..)). body(namePath + "last", is(..)). when(). get(..);you can use a append root and do:
String namePath = "name"; expect(). rootPath("x.y"). body("age", is(..)). body("gender", is(..)). appendRootPath("%s", withArgs(namePath)). body("first", is(..)). body("last", is(..)). when(). get(..);
pathToAppend
- The root path to use. The path and arguments follows the standard formatting syntax of Java.default ResponseSpecification appendRoot(String pathToAppend, List<Argument> arguments)
appendRootPath(String, List)
insteadpathToAppend
- The root path to append.appendRootPath(String, List)
@Deprecated default ResponseSpecification appendRoot(String pathToAppend)
appendRootPath(String)
insteadpathToAppend
- The root path to append.appendRootPath(String)
ResponseSpecification detachRootPath(String pathToDetach)
when(). get(..); then(). rootPath("x.y"). body("age", is(..)). body("gender", is(..)). rootPath("x"). body("firstName", is(..)). body("lastName", is(..)).you can use a append root and do:
when(). get(..); then(). rootPath("x.y"). body("age", is(..)). body("gender", is(..)). detachRootPath("y"). body("firstName", is(..)). body("lastName", is(..)).
pathToDetach
- The root path to detach.@Deprecated default ResponseSpecification detachRoot(String pathToDetach)
detachRootPath(String)
insteadpathToDetach
- The root path to detach.detachRootPath(String)
ResponseSpecification contentType(ContentType contentType)
contentType
.contentType
- The content type of the response.ResponseSpecification contentType(String contentType)
contentType
.contentType
- The content type of the response.ResponseSpecification contentType(org.hamcrest.Matcher<? super String> contentType)
contentType
.contentType
- The expected content type of the response.ResponseSpecification body(org.hamcrest.Matcher<?> matcher, org.hamcrest.Matcher<?>... additionalMatchers)
// Expect that the response body (content) contains the string "winning-numbers" when().get("/lotto").then().body(containsString("winning-numbers")); // Expect that the response body (content) contains the string "winning-numbers" and "winners" when().get("/lotto").then().body(containsString("winning-numbers"), containsString("winners"));
matcher
- The hamcrest matcher that must response body must match.additionalMatchers
- Optionally additional hamcrest matchers that must return true
.ResponseSpecification body(String path, org.hamcrest.Matcher<?> matcher, Object... additionalKeyMatcherPairs)
Assume that a GET request to "/lotto" returns a JSON response containing:
{ "lotto":{ "lottoId":5, "winning-numbers":[2,45,34,23,7,5,3], "winners":[{ "winnerId":23, "numbers":[2,45,34,23,3,5] },{ "winnerId":54, "numbers":[52,3,12,11,18,22] }] }}You can verify that the lottoId is equal to 5 like this:
when().get("/lotto").then().body("lotto.lottoId", equalTo(5));You can also verify that e.g. one of the the winning numbers is 45.
when().get("/lotto").then().body("lotto.winning-numbers", hasItem(45));Or both at the same time:
when().get("/lotto").then().body("lotto.lottoId", equalTo(5)).and().body("lotto.winning-numbers", hasItem(45));or a slightly short version:
when().get("/lotto").then().body("lotto.lottoId", equalTo(5), "lotto.winning-numbers", hasItem(45));
Assume that a GET request to "/xml" returns a XML response containing:
<greeting> <firstName>John</firstName> <lastName>Doe</lastName> </greeting>You can now verify that the firstName is equal to "John" like this:
when().get("/xml").then().body("greeting.firstName", equalTo("John"));To verify both the first name and last name you can do like this:
when().get("/xml").then().body("greeting.firstName", equalTo("John")).and().body("greeting.lastName", equalTo("Doe"));Or the slightly shorter version of:
when().get("/xml").then().body("greeting.firstName", equalTo("John"), "greeting.lastName", equalTo("Doe"));
Note that if the response body type is not of type application/xml or application/json you cannot use this verification.
The only difference between the content
and body
methods are of syntactic nature.
path
- The body pathmatcher
- The hamcrest matcher that must response body must match.additionalKeyMatcherPairs
- Optionally additional hamcrest matchers that must return true
.RequestSender when()
expect().body(containsString("OK")).when().get("/something");is that same as:
expect().body(containsString("OK")).get("/something");
RequestSpecification given()
expect().body(containsString("OK")).given().parameters("param1", "value1").when().get("/something");
ResponseSpecification that()
expect().that().body(containsString("OK")).when().get("/something");is that same as:
expect().body(containsString("OK")).get("/something");
RequestSpecification request()
expect().body(containsString("OK")).and().request().parameters("param1", "value1").when().get("/something");
ResponseSpecification response()
expect().response().body(containsString("OK")).when().get("/something");is that same as:
expect().body(containsString("OK")).get("/something");
ResponseSpecification and()
expect().body(containsString("OK")).and().body(containsString("something else")).when().get("/something");is that same as:
expect().body(containsString("OK")).body(containsString("something else")).when().get("/something");
RequestSpecification with()
expect().body(containsString("OK")).and().with().request().parameters("param1", "value1").get("/something");
ResponseSpecification then()
expect().body(containsString("OK")).then().get("/something");is that same as:
expect().body(containsString("OK")).get("/something");
ResponseSpecification expect()
expect().body(containsString("OK")).and().expect().body(containsString("something else")).when().get("/something");is that same as:
* expect().body(containsString("OK")).and().body(containsString("something else")).when().get("/something");
ResponseSpecification spec(ResponseSpecification responseSpecificationToMerge)
ResponseSpecification responseSpec = new ResponseSpecBuilder().expectStatusCode(200).build(); when(). get("/something"). then(). spec(responseSpec). body("x.y.z", equalTo("something"));This is useful when you want to reuse multiple different expectations in several tests. The specification passed to this method is merged with the current specification. Note that the supplied specification can overwrite data in the current specification. The following settings are overwritten:
responseSpecificationToMerge
- The specification to merge with.ResponseSpecification parser(String contentType, Parser parser)
expect().body("document.child", equalsTo("something"))..Since application/vnd.uoml+xml is not registered to be processed by the XML parser by default you need to explicitly tell REST Assured to use this parser before making the request:
expect().parser("application/vnd.uoml+xml", Parser.XML).when(). ..;You can also specify by it for every response by using:
RestAssured.registerParser("application/vnd.uoml+xml", Parser.XML);
contentType
- The content-type to registerparser
- The parser to use when verifying the response.ResponseSpecification defaultParser(Parser parser)
expect().defaultParser(Parser.JSON).when(). ..;You can also specify it for every response by using:
RestAssured.defaultParser(Parser.JSON);
parser
- The parser to use when verifying the response if no other parser is found for the response content-type.ResponseSpecification logDetail(LogDetail logDetail)
ResponseSpecification
by using LogDetail
.
This is mainly useful for debug purposes when writing your tests. It's a shortcut for:
given().filter(new ResponseLoggingFilter(logDetail))). ..
logDetail
- The log detailCopyright © 2010–2019. All rights reserved.