public class ResponseSpecificationImpl extends Object implements FilterableResponseSpecification, groovy.lang.GroovyObject
Modifier and Type | Class and Description |
---|---|
class |
ResponseSpecificationImpl.HamcrestAssertionClosure |
Constructor and Description |
---|
ResponseSpecificationImpl(String bodyRootPath,
ResponseSpecification defaultSpec,
ResponseParserRegistrar rpr,
RestAssuredConfig config,
LogRepository logRepository) |
ResponseSpecificationImpl(String bodyRootPath,
ResponseSpecification defaultSpec,
ResponseParserRegistrar rpr,
RestAssuredConfig config,
Response response,
LogRepository logRepository) |
Modifier and Type | Method and Description |
---|---|
ResponseSpecification |
and()
Syntactic sugar, e.g.
|
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 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 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 arguments,
org.hamcrest.Matcher matcher,
Object... additionalKeyMatcherPairs)
Same as
ResponseSpecification.body(String, org.hamcrest.Matcher, Object...) expect that you can pass arguments to the key. |
ResponseSpecification |
body(String key,
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 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 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.
|
ResponseSpecification |
detachRootPath(String pathToDetach)
Detach the given path from the root path.
|
ResponseSpecification |
expect()
Syntactic sugar, e.g.
|
Object |
forceDisableEagerAssert() |
Object |
forceValidateResponse() |
RestAssuredConfig |
getConfig() |
LogDetail |
getLogDetail() |
LogRepository |
getLogRepository() |
groovy.lang.MetaClass |
getMetaClass() |
Object |
getProperty(String property) |
String |
getResponseContentType() |
String |
getRootPath() |
ResponseParserRegistrar |
getRpr() |
org.hamcrest.Matcher |
getStatusCode() |
org.hamcrest.Matcher |
getStatusLine() |
RequestSpecification |
given()
Returns the request io.restassured.specification so that you can define the properties of the request.
|
boolean |
hasAssertionsDefined() |
boolean |
hasBodyAssertionsDefined() |
boolean |
hasCookieAssertions() |
boolean |
hasHeaderAssertions() |
ResponseSpecification |
header(String headerName,
java.util.function.Function mappingFunction,
org.hamcrest.Matcher 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 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.
|
Object |
invokeMethod(String method,
Object arguments) |
ResponseLogSpecification |
log()
Returns the
ResponseLogSpecification that allows you to log different parts of the ResponseSpecification . |
ResponseSpecificationImpl |
logDetail(LogDetail logDetail)
Log different parts of the
ResponseSpecification by using LogDetail . |
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.
|
ResponseSpecification |
root(String rootPath,
List arguments) |
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 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.
|
void |
setConfig(RestAssuredConfig value) |
void |
setLogRepository(LogRepository value) |
void |
setMetaClass(groovy.lang.MetaClass mc) |
void |
setProperty(String property,
Object value) |
void |
setRpr(ResponseParserRegistrar value) |
ResponseSpecification |
spec(ResponseSpecification responseSpecificationToMerge)
Expect that the response matches an entire specification.
|
ResponseSpecification |
specification(ResponseSpecification responseSpecificationToMerge) |
ResponseSpecification |
statusCode(int expectedStatusCode)
Expect that the response status code matches an integer.
|
ResponseSpecification |
statusCode(org.hamcrest.Matcher expectedStatusCode)
Expect that the response status code matches the given Hamcrest matcher.
|
ResponseSpecification |
statusLine(org.hamcrest.Matcher 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.
|
void |
throwIllegalStateExceptionIfRootPathIsNotDefined(String description) |
ResponseSpecification |
time(org.hamcrest.Matcher matcher)
Validate that the response time (in milliseconds) matches the supplied
matcher . |
ResponseSpecification |
time(org.hamcrest.Matcher 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.
|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
appendRoot, appendRoot, detachRoot, noRoot, root
public ResponseSpecificationImpl(String bodyRootPath, ResponseSpecification defaultSpec, ResponseParserRegistrar rpr, RestAssuredConfig config, LogRepository logRepository)
public ResponseSpecificationImpl(String bodyRootPath, ResponseSpecification defaultSpec, ResponseParserRegistrar rpr, RestAssuredConfig config, Response response, LogRepository logRepository)
public ResponseParserRegistrar getRpr()
public void setRpr(ResponseParserRegistrar value)
public RestAssuredConfig getConfig()
public void setConfig(RestAssuredConfig value)
public LogRepository getLogRepository()
public void setLogRepository(LogRepository value)
public ResponseSpecification body(List arguments, org.hamcrest.Matcher matcher, Object... additionalKeyMatcherPairs)
ResponseSpecification
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(..)).
body
in interface ResponseSpecification
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
.ResponseSpecification.body(String, org.hamcrest.Matcher, Object...)
public Response validate(Response response)
ResponseSpecification
validate
in interface ResponseSpecification
response
- The response to validatepublic ResponseSpecification body(org.hamcrest.Matcher matcher, org.hamcrest.Matcher... additionalMatchers)
ResponseSpecification
// 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"));
body
in interface ResponseSpecification
matcher
- The hamcrest matcher that must response body must match.additionalMatchers
- Optionally additional hamcrest matchers that must return true
.public ResponseSpecification body(String key, org.hamcrest.Matcher matcher, Object... additionalKeyMatcherPairs)
ResponseSpecification
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.
body
in interface ResponseSpecification
key
- The body pathmatcher
- The hamcrest matcher that must response body must match.additionalKeyMatcherPairs
- Optionally additional hamcrest matchers that must return true
.public ResponseSpecification time(org.hamcrest.Matcher matcher)
ResponseSpecification
matcher
. For example:
when(). get("/something"). then(). time(lessThan(2000L));where
lessThan
is a Hamcrest matchertime
in interface ResponseSpecification
ValidatableResponse
instance.public ResponseSpecification time(org.hamcrest.Matcher matcher, TimeUnit timeUnit)
ResponseSpecification
matcher
and time unit. For example:
when(). get("/something"). then(). time(lessThan(2L), TimeUnit.SECONDS);where
lessThan
is a Hamcrest matchertime
in interface ResponseSpecification
ValidatableResponse
instance.public ResponseSpecification statusCode(org.hamcrest.Matcher expectedStatusCode)
ResponseSpecification
expect().statusCode(equalTo(200)).when().get("/something");
statusCode
in interface ResponseSpecification
expectedStatusCode
- The expected status code matcher.public ResponseSpecification statusCode(int expectedStatusCode)
ResponseSpecification
expect().statusCode(200).when().get("/something");This is the same as:
expect().statusCode(equalTo(200)).when().get("/something");
statusCode
in interface ResponseSpecification
expectedStatusCode
- The expected status code.public ResponseSpecification statusLine(org.hamcrest.Matcher expectedStatusLine)
ResponseSpecification
expect().statusLine(equalTo("No Content")).when().get("/something");
statusLine
in interface ResponseSpecification
expectedStatusLine
- The expected status line matcher.public ResponseSpecification headers(Map expectedHeaders)
ResponseSpecification
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");
headers
in interface ResponseSpecification
expectedHeaders
- The Map of expected response headerspublic ResponseSpecification headers(String firstExpectedHeaderName, Object firstExpectedHeaderValue, Object... expectedHeaders)
ResponseSpecification
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");
headers
in interface ResponseSpecification
firstExpectedHeaderName
- The name of the first headerfirstExpectedHeaderValue
- The value of the first headerexpectedHeaders
- A list of expected "header name" - "header value" pairs.public ResponseSpecification header(String headerName, java.util.function.Function mappingFunction, org.hamcrest.Matcher expectedValueMatcher)
ResponseSpecification
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));
header
in interface ResponseSpecification
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 valuepublic ResponseSpecification header(String headerName, org.hamcrest.Matcher expectedValueMatcher)
ResponseSpecification
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
ResponseSpecification.headers(String, Object, Object...)
)} for a short version of passing multiple headers.
header
in interface ResponseSpecification
headerName
- The name of the expected headerexpectedValueMatcher
- The Hamcrest matcher that must conform to the valuepublic ResponseSpecification header(String headerName, String expectedValue)
ResponseSpecification
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
ResponseSpecification.headers(String, Object, Object...)
for a short version of passing multiple headers.
header
in interface ResponseSpecification
headerName
- The name of the expected headerexpectedValue
- The value of the expected headerpublic ResponseSpecification cookies(Map expectedCookies)
ResponseSpecification
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");
cookies
in interface ResponseSpecification
expectedCookies
- A Map of expected response cookiespublic ResponseSpecification cookies(String firstExpectedCookieName, Object firstExpectedCookieValue, Object... expectedCookieNameValuePairs)
ResponseSpecification
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");
cookies
in interface ResponseSpecification
firstExpectedCookieName
- The name of the first cookiefirstExpectedCookieValue
- The value of the first cookieexpectedCookieNameValuePairs
- A list of expected "cookie name" - "cookie value" pairs.public ResponseSpecification cookie(String cookieName, org.hamcrest.Matcher expectedValueMatcher)
ResponseSpecification
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
ResponseSpecification.cookies(String, Object, Object...)
for a short version of passing multiple cookies.
cookie
in interface ResponseSpecification
cookieName
- The name of the expected cookieexpectedValueMatcher
- The Hamcrest matcher that must conform to the valuepublic ResponseSpecification cookie(String cookieName, DetailedCookieMatcher detailedCookieMatcher)
ResponseSpecification
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));
cookie
in interface ResponseSpecification
cookieName
- The name of the expected cookiedetailedCookieMatcher
- The Hamcrest matcher that must conform to the cookiepublic ResponseSpecification cookie(String cookieName)
ResponseSpecification
cookie
in interface ResponseSpecification
cookieName
- the cookie to validate that it existspublic ResponseSpecification cookie(String cookieName, Object expectedValue)
ResponseSpecification
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
ResponseSpecification.cookies(String, Object, Object...)
for a short version of passing multiple cookies.
cookie
in interface ResponseSpecification
cookieName
- The name of the expected cookieexpectedValue
- The value of the expected cookiepublic ResponseSpecification spec(ResponseSpecification responseSpecificationToMerge)
ResponseSpecification
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:
spec
in interface ResponseSpecification
responseSpecificationToMerge
- The specification to merge with.public ResponseSpecification specification(ResponseSpecification responseSpecificationToMerge)
public ResponseSpecification statusLine(String expectedStatusLine)
ResponseSpecification
expect().statusLine("No Content").when().get("/something");This is the same as:
expect().statusLine(equalTo("No Content")).when().get("/something");
statusLine
in interface ResponseSpecification
expectedStatusLine
- The expected status line.public ResponseSpecification body(String key, List arguments, org.hamcrest.Matcher matcher, Object... additionalKeyMatcherPairs)
ResponseSpecification
ResponseSpecification.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.
body
in interface ResponseSpecification
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
.ResponseSpecification.body(String, org.hamcrest.Matcher, Object...)
public ResponseLogSpecification log()
ResponseSpecification
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()). ..
log
in interface ResponseSpecification
public ResponseSpecificationImpl logDetail(LogDetail logDetail)
ResponseSpecification
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
in interface ResponseSpecification
logDetail
- The log detailpublic LogDetail getLogDetail()
getLogDetail
in interface FilterableResponseSpecification
public RequestSender when()
ResponseSpecification
expect().body(containsString("OK")).when().get("/something");is that same as:
expect().body(containsString("OK")).get("/something");
when
in interface ResponseSpecification
public ResponseSpecification response()
ResponseSpecification
expect().response().body(containsString("OK")).when().get("/something");is that same as:
expect().body(containsString("OK")).get("/something");
response
in interface ResponseSpecification
public RequestSpecification given()
ResponseSpecification
expect().body(containsString("OK")).given().parameters("param1", "value1").when().get("/something");
given
in interface ResponseSpecification
public ResponseSpecification that()
ResponseSpecification
expect().that().body(containsString("OK")).when().get("/something");is that same as:
expect().body(containsString("OK")).get("/something");
that
in interface ResponseSpecification
public RequestSpecification request()
ResponseSpecification
expect().body(containsString("OK")).and().request().parameters("param1", "value1").when().get("/something");
request
in interface ResponseSpecification
public ResponseSpecification parser(String contentType, Parser parser)
ResponseSpecification
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);
parser
in interface ResponseSpecification
contentType
- The content-type to registerparser
- The parser to use when verifying the response.public ResponseSpecification and()
ResponseSpecification
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");
and
in interface ResponseSpecification
public RequestSpecification with()
ResponseSpecification
expect().body(containsString("OK")).and().with().request().parameters("param1", "value1").get("/something");
with
in interface ResponseSpecification
public ResponseSpecification then()
ResponseSpecification
expect().body(containsString("OK")).then().get("/something");is that same as:
expect().body(containsString("OK")).get("/something");
then
in interface ResponseSpecification
public ResponseSpecification expect()
ResponseSpecification
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");
expect
in interface ResponseSpecification
public ResponseSpecification rootPath(String rootPath)
ResponseSpecification
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
in interface ResponseSpecification
rootPath
- The root path to use.public ResponseSpecification noRootPath()
ResponseSpecification
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.noRootPath
in interface ResponseSpecification
ResponseSpecification.rootPath(String)
public ResponseSpecification appendRootPath(String pathToAppend)
ResponseSpecification
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(..);
appendRootPath
in interface ResponseSpecification
pathToAppend
- The root path to append.public ResponseSpecification appendRootPath(String pathToAppend, List arguments)
ResponseSpecification
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(..);
appendRootPath
in interface ResponseSpecification
pathToAppend
- The root path to use. The path and arguments follows the standard formatting syntax of Java.public ResponseSpecification detachRootPath(String pathToDetach)
ResponseSpecification
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(..)).
detachRootPath
in interface ResponseSpecification
pathToDetach
- The root path to detach.public ResponseSpecification rootPath(String rootPath, List arguments)
ResponseSpecification
rootPath
in interface ResponseSpecification
rootPath
- The root path to use.arguments
- The list of substitution arguments. The path and arguments follows the standard formatting syntax of Java..public ResponseSpecification root(String rootPath, List arguments)
root
in interface ResponseSpecification
rootPath
- The root path to use.arguments
- The list of substitution arguments. The path and arguments follows the standard formatting syntax of Java..ResponseSpecification.rootPath(String, List)
public boolean hasBodyAssertionsDefined()
public boolean hasAssertionsDefined()
public ResponseSpecification defaultParser(Parser parser)
ResponseSpecification
expect().defaultParser(Parser.JSON).when(). ..;You can also specify it for every response by using:
RestAssured.defaultParser(Parser.JSON);
defaultParser
in interface ResponseSpecification
parser
- The parser to use when verifying the response if no other parser is found for the response content-type.public ResponseSpecification contentType(ContentType contentType)
ResponseSpecification
contentType
.contentType
in interface ResponseSpecification
contentType
- The content type of the response.public ResponseSpecification contentType(String contentType)
ResponseSpecification
contentType
.contentType
in interface ResponseSpecification
contentType
- The content type of the response.public ResponseSpecification contentType(org.hamcrest.Matcher contentType)
ResponseSpecification
contentType
.contentType
in interface ResponseSpecification
contentType
- The expected content type of the response.public org.hamcrest.Matcher getStatusCode()
getStatusCode
in interface FilterableResponseSpecification
null
).public org.hamcrest.Matcher getStatusLine()
getStatusLine
in interface FilterableResponseSpecification
null
).public boolean hasHeaderAssertions()
hasHeaderAssertions
in interface FilterableResponseSpecification
true
if any header assertions are definedpublic boolean hasCookieAssertions()
hasCookieAssertions
in interface FilterableResponseSpecification
true
if any cookie assertions are definedpublic String getResponseContentType()
getResponseContentType
in interface FilterableResponseSpecification
public String getRootPath()
getRootPath
in interface FilterableResponseSpecification
public void throwIllegalStateExceptionIfRootPathIsNotDefined(String description)
public Object forceDisableEagerAssert()
public Object forceValidateResponse()
public groovy.lang.MetaClass getMetaClass()
getMetaClass
in interface groovy.lang.GroovyObject
public void setMetaClass(groovy.lang.MetaClass mc)
setMetaClass
in interface groovy.lang.GroovyObject
public Object invokeMethod(String method, Object arguments)
invokeMethod
in interface groovy.lang.GroovyObject
public Object getProperty(String property)
getProperty
in interface groovy.lang.GroovyObject
Copyright © 2010–2019. All rights reserved.