ValidatableResponseImpl (REST Assured 4.2.0 API)

java.lang.Object
- io.restassured.internal.ValidatableResponseOptionsImpl
- - io.restassured.internal.ValidatableResponseImpl

All Implemented Interfaces:

groovy.lang.GroovyObject, ValidatableResponse, ValidatableResponseLogSpec, ValidatableResponseOptions<ValidatableResponse,Response>
```
public class ValidatableResponseImpl
extends ValidatableResponseOptionsImpl
implements ValidatableResponse, groovy.lang.GroovyObject
```

Field Summary
- Fields inherited from class io.restassured.internal.ValidatableResponseOptionsImpl
  response, responseSpec

Constructor Summary

Constructors
Constructor and Description
`ValidatableResponseImpl(String contentType, ResponseParserRegistrar rpr, RestAssuredConfig config, Response response, ExtractableResponse extractableResponse, LogRepository logRepository)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ValidatableResponse`	`all()` Logs everything in the response, including e.g.
`ValidatableResponse`	`all(boolean shouldPrettyPrint)` Logs everything in the response, including e.g.
`ValidatableResponse`	`and()` Syntactic sugar, e.g.
`ValidatableResponse`	`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.
`ValidatableResponse`	`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.
`ValidatableResponse`	`assertThat()` Syntactic sugar, e.g.
`ValidatableResponse`	`body()` Logs only the content of the body.
`ValidatableResponse`	`body(boolean shouldPrettyPrint)` Logs only the content of the body and pretty-print the body if specified.
`ValidatableResponse`	`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.
`ValidatableResponse`	`body(List arguments, ResponseAwareMatcher responseAwareMatcher)` Compare a path in the response body to something available in the response using arguments when root path is used.
`ValidatableResponse`	`body(org.hamcrest.Matcher matcher, org.hamcrest.Matcher... additionalMatchers)` Validate that the response body conforms to one or more Hamcrest matchers.
`ValidatableResponse`	`body(String path, List arguments, org.hamcrest.Matcher matcher, Object... additionalKeyMatcherPairs)` Same as `ValidatableResponseOptions.body(String, org.hamcrest.Matcher, Object...)` expect that you can pass arguments to the key.
`ValidatableResponse`	`body(String key, List arguments, ResponseAwareMatcher responseAwareMatcher)` Compare a path in the response body to something available in the response using arguments.
`ValidatableResponse`	`body(String path, org.hamcrest.Matcher matcher, Object... additionalKeyMatcherPairs)` Validate that the JSON or XML response body conforms to one or more Hamcrest matchers.
`ValidatableResponse`	`body(String key, ResponseAwareMatcher responseAwareMatcher)` Compare a path in the response body to something available in the response, for example another path.
`ValidatableResponse`	`content(String path, List arguments, org.hamcrest.Matcher matcher, Object... additionalKeyMatcherPairs)`
`ValidatableResponse`	`contentType(ContentType contentType)` Set the response content type to be `contentType`.
`ValidatableResponse`	`contentType(org.hamcrest.Matcher contentType)` Validate the response content type to be `contentType`.
`ValidatableResponse`	`contentType(String contentType)` Set the response content type to be `contentType`.
`ValidatableResponse`	`cookie(String cookieName)` Validate that a cookie exist in the response, regardless of value (it may have no value at all).
`ValidatableResponse`	`cookie(String cookieName, DetailedCookieMatcher detailedCookieMatcher)` Validate that a detailed response cookie matches the supplied cookie name and hamcrest matcher (see `DetailedCookieMatcher`).
`ValidatableResponse`	`cookie(String cookieName, org.hamcrest.Matcher expectedValueMatcher)` Validate that a response cookie matches the supplied cookie name and hamcrest matcher.
`ValidatableResponse`	`cookie(String cookieName, Object expectedValue)` Validate that a response cookie matches the supplied name and value.
`ValidatableResponse`	`cookies()` Logs only the cookies.
`ValidatableResponse`	`cookies(Map expectedCookies)` Validate that response cookies matches those specified in a Map.
`ValidatableResponse`	`cookies(String firstExpectedCookieName, Object firstExpectedCookieValue, Object... expectedCookieNameValuePairs)` Validate that response cookies matches the supplied cookie names and values.
`ValidatableResponse`	`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.
`ValidatableResponse`	`detachRootPath(String pathToDetach)` Detach the given path from the root path.
`ValidatableResponse`	`everything()` Logs everything in the response, including e.g.
`ValidatableResponse`	`everything(boolean shouldPrettyPrint)` * Logs everything in the response, including e.g.
`ExtractableResponse`	`extract()` Extract values from the response or return the response instance itself.
`groovy.lang.MetaClass`	`getMetaClass()`
`Object`	`getProperty(String property)`
`ValidatableResponse`	`header(String headerName, java.util.function.Function f, org.hamcrest.Matcher matcher)` Expect that a response header matches the supplied header name and hamcrest matcher using a mapping function.
`ValidatableResponse`	`header(String headerName, org.hamcrest.Matcher expectedValueMatcher)` Validate that a response header matches the supplied header name and hamcrest matcher.
`ValidatableResponse`	`header(String headerName, ResponseAwareMatcher r)` Compare a header in the response to something else available in the response.
`ValidatableResponse`	`header(String headerName, String expectedValue)` Validate that a response header matches the supplied name and value.
`ValidatableResponse`	`headers()` Logs only the headers.
`ValidatableResponse`	`headers(Map expectedHeaders)` Validate that response headers matches those specified in a Map.
`ValidatableResponse`	`headers(String firstExpectedHeaderName, Object firstExpectedHeaderValue, Object... expectedHeaders)` Validate that response headers matches the supplied headers and values.
`ValidatableResponse`	`ifError()` Logs everything only if an error occurs (status code >= 400).
`ValidatableResponse`	`ifStatusCodeIsEqualTo(int statusCode)` Logs everything only if if the status code is equal to `statusCode`.
`ValidatableResponse`	`ifStatusCodeMatches(org.hamcrest.Matcher matcher)` Logs everything only if if the status code matches the supplied `matcher`
`ValidatableResponse`	`ifValidationFails()` Logs everything if a test validation fails.
`ValidatableResponse`	`ifValidationFails(LogDetail logDetail)` Logs with the supplied log detail only if the validation fails.
`ValidatableResponse`	`ifValidationFails(LogDetail logDetail, boolean shouldPrettyPrint)` Logs all parameters only if the validations fail.
`Object`	`invokeMethod(String method, Object arguments)`
`ValidatableResponseLogSpec`	`log()` Returns the `ValidatableResponseLogSpec` that allows you to log different parts of the `Response`.
`ValidatableResponse`	`noRoot()` Reset the root path of the response body so that you don't need to write the entire path for each expectation.
`ValidatableResponse`	`noRootPath()` Reset the root path of the response body so that you don't need to write the entire path for each expectation.
`Response`	`originalResponse()`
`ValidatableResponse`	`parser(String contentType, Parser parser)` Register a content-type to be parsed using a predefined parser.
`ValidatableResponse`	`root(String rootPath)` Set the root path of the response body so that you don't need to write the entire path for each expectation.
`ValidatableResponse`	`root(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.
`ValidatableResponse`	`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.
`ValidatableResponse`	`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`	`setMetaClass(groovy.lang.MetaClass mc)`
`void`	`setProperty(String property, Object value)`
`ValidatableResponse`	`spec(ResponseSpecification responseSpecification)` Validate that the response matches an entire specification.
`ValidatableResponse`	`status()` Logs only the status line (includes the status code)
`ValidatableResponse`	`statusCode(int expectedStatusCode)` Validate that the response status code matches an integer.
`ValidatableResponse`	`statusCode(org.hamcrest.Matcher expectedStatusCode)` Validate that the response status code matches the given Hamcrest matcher.
`ValidatableResponse`	`statusLine(org.hamcrest.Matcher expectedStatusLine)` Validate that the response status line matches the given Hamcrest matcher.
`ValidatableResponse`	`statusLine(String expectedStatusLine)` Validate that the response status line matches the given String.
`ValidatableResponse`	`time(org.hamcrest.Matcher matcher)` Validate that the response time (in milliseconds) matches the supplied `matcher`.
`ValidatableResponse`	`time(org.hamcrest.Matcher matcher, TimeUnit timeUnit)` Validate that the response time matches the supplied `matcher` and time unit.
`ValidatableResponse`	`using()` Syntactic sugar, e.g.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface io.restassured.response.ValidatableResponseOptions
appendRoot, appendRoot, detachRoot

- Constructor Detail
  - ValidatableResponseImpl
```
public ValidatableResponseImpl(String contentType,
                               ResponseParserRegistrar rpr,
                               RestAssuredConfig config,
                               Response response,
                               ExtractableResponse extractableResponse,
                               LogRepository logRepository)
```
- Method Detail
  - originalResponse
```
public Response originalResponse()
```
    Specified by:
    
    originalResponse in class ValidatableResponseOptionsImpl
  - time
```
public ValidatableResponse time(org.hamcrest.Matcher matcher)
```
    Description copied from interface: ValidatableResponseOptions
    Validate that the response time (in milliseconds) matches the supplied matcher. For example:
```
 when().
        get("/something").
 then().
        time(lessThan(2000));
 
```
    where lessThan is a Hamcrest matcher
    Specified by:
    
    time in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    time in class ValidatableResponseOptionsImpl
    
    Returns:
    
    The ValidatableResponse instance.
  - time
```
public ValidatableResponse time(org.hamcrest.Matcher matcher,
                                TimeUnit timeUnit)
```
    Description copied from interface: ValidatableResponseOptions
    Validate that the response time matches the supplied matcher and time unit. For example:
```
 when().
        get("/something").
 then().
        time(lessThan(2), TimeUnit.SECONDS);
 
```
    where lessThan is a Hamcrest matcher
    Specified by:
    
    time in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    time in class ValidatableResponseOptionsImpl
    
    Returns:
    
    The ValidatableResponse instance.
  - defaultParser
```
public ValidatableResponse defaultParser(Parser parser)
```
    Description copied from interface: ValidatableResponseOptions
    Register a default predefined parser that will be used if no other parser (registered or pre-defined) matches the response content-type. E.g. let's say that for some reason no content-type is defined in the response but the content is nevertheless JSON encoded. To be able to expect the content in REST Assured you need to set the default parser:
```
 get("/x").then().using().defaultParser(Parser.JSON).assertThat(). ..;
 
```
    You can also specify it for every response by using:
```
 RestAssured.defaultParser(Parser.JSON);
 
```
    Specified by:
    
    defaultParser in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    defaultParser in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    parser - The parser to use when verifying the response if no other parser is found for the response content-type.
  - parser
```
public ValidatableResponse parser(String contentType,
                                  Parser parser)
```
    Description copied from interface: ValidatableResponseOptions
    Register a content-type to be parsed using a predefined parser. E.g. let's say you want parse content-type application/custom with the XML parser to be able to verify the response using the XML dot notations:
```
 get("/x").then().assertThat().body("document.child", equalsTo("something")
 
```
    Since application/custom 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:
```
 get("/x").then().parser("application/custom", Parser.XML).assertThat(). ..;
 
```
    You can also specify by it for every response by using:
```
 RestAssured.registerParser("application/custom", Parser.XML);
 
```
    Specified by:
    
    parser in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    parser in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    contentType - The content-type to register
    
    parser - The parser to use when verifying the response.
  - spec
```
public ValidatableResponse spec(ResponseSpecification responseSpecification)
```
    Description copied from interface: ValidatableResponseOptions
    Validate that the response matches an entire specification.
```
 ResponseSpecification responseSpec = new ResponseSpecBuilder().expectStatusCode(200).build();
 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:
    - Content type
    - Root pathStatus code
    - Status line
    The following settings are merged:
    - Response body expectations
    - Cookies
    - Headers
    Specified by:
    
    spec in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    spec in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    responseSpecification - The specification to merge with.
    
    Returns:
    
    the response specification
  - assertThat
```
public ValidatableResponse assertThat()
```
    Description copied from interface: ValidatableResponseOptions
    Syntactic sugar, e.g.
```
 get("/something").then().assertThat().body(containsString("OK")).and().body(containsString("something else"));
 
```
    is that same as:
```
 get("/something").then().body(containsString("OK")).body(containsString("something else"));
 
```
    Specified by:
    
    assertThat in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    assertThat in class ValidatableResponseOptionsImpl
    
    Returns:
    
    the response specification
  - using
```
public ValidatableResponse using()
```
    Description copied from interface: ValidatableResponseOptions
    Syntactic sugar, e.g.
```
 get("/something").then().using().defaultParser(JSON).assertThat().body(containsString("OK")).and().body(containsString("something else"));
 
```
    is that same as:
```
 get("/something").then().defaultParser(JSON).body(containsString("OK")).body(containsString("something else"));
 
```
    Specified by:
    
    using in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    using in class ValidatableResponseOptionsImpl
    
    Returns:
    
    the response specification
  - and
```
public ValidatableResponse and()
```
    Description copied from interface: ValidatableResponseOptions
    Syntactic sugar, e.g.
```
 get("/something").then().assertThat().body(containsString("OK")).and().body(containsString("something else"));
 
```
    is that same as:
```
 get("/something").then().assertThat().body(containsString("OK")).body(containsString("something else"));
 
```
    Specified by:
    
    and in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    and in class ValidatableResponseOptionsImpl
    
    Returns:
    
    the response specification
  - all
```
public ValidatableResponse all()
```
    Description copied from interface: ValidatableResponseLogSpec
    
    Logs everything in the response, including e.g. headers, cookies, body. Pretty-prints the body if content-type is either either XML, JSON or HTML..
    
    Specified by:
    
    all in interface ValidatableResponseLogSpec
    
    Overrides:
    
    all in class ValidatableResponseOptionsImpl
    
    Returns:
    
    The specification
  - body
```
public ValidatableResponse body(List arguments,
                                ResponseAwareMatcher responseAwareMatcher)
```
    Description copied from interface: ValidatableResponseOptions
    Compare a path in the response body to something available in the response using arguments when root path is used. For example imagine that a resource "/x" returns the following JSON document:
```
 {
    "data" : {
        "user1" : {
             "userId" : "my-id1",
             "href" : "http://localhost:8080/my-id1"
        },
        "user2" : {
             "userId" : "my-id2",
             "href" : "http://localhost:8080/my-id2"
        },
    }
 }
 
```
    you can then verify the href using:
```
 when().
        get("/x").
 then().
        root("data.%s").
        body(withArgs("user1"), new ResponseAwareMatcher() {
                       public Matcher matcher(Response response) {
                           return equalTo("http://localhost:8080/" + response.path("userId"));
                       }
                  });
 
```
    Note that you can also use some of the predefined methods in RestAssuredMatchers.
    Specified by:
    
    body in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    body in class ValidatableResponseOptionsImpl
    
    responseAwareMatcher - The ResponseAwareMatcher that creates the Hamcrest matcher.
    
    Returns:
    
    the response specification
    
    See Also:
    
    ValidatableResponseOptions.body(String, ResponseAwareMatcher), RestAssuredMatchers.endsWithPath(String), RestAssuredMatchers.startsWithPath(String), RestAssuredMatchers.containsPath(String), RestAssuredMatchers.equalToPath(String)
  - body
```
public ValidatableResponse body(String key,
                                List arguments,
                                ResponseAwareMatcher responseAwareMatcher)
```
    Description copied from interface: ValidatableResponseOptions
    Compare a path in the response body to something available in the response using arguments. For example imagine that a resource "/x" returns the following JSON document:
```
 {
      "userId" : "my-id",
      "my.href" : "http://localhost:8080/my-id"
 }
 
```
    you can then verify the href using:
```
 get("/x").then().body("%s.href", withArgs("my"), new ResponseAwareMatcher() {
                       public Matcher matcher(Response response) {
                           return equalTo("http://localhost:8080/" + response.path("userId"));
                       }
                  });
 
```
    Note that you can also use some of the predefined methods in RestAssuredMatchers.
    Specified by:
    
    body in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    body in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    key - The body path
    
    responseAwareMatcher - The ResponseAwareMatcher that creates the Hamcrest matcher.
    
    Returns:
    
    the response specification
    
    See Also:
    
    ValidatableResponseOptions.body(String, ResponseAwareMatcher), RestAssuredMatchers.endsWithPath(String), RestAssuredMatchers.startsWithPath(String), RestAssuredMatchers.containsPath(String), RestAssuredMatchers.equalToPath(String)
  - body
```
public ValidatableResponse body(String key,
                                ResponseAwareMatcher responseAwareMatcher)
```
    Description copied from interface: ValidatableResponseOptions
    Compare a path in the response body to something available in the response, for example another path. For example imagine that a resource "/x" returns the following JSON document:
```
 {
      "userId" : "my-id",
      "href" : "http://localhost:8080/my-id"
 }
 
```
    you can then verify the href using:
```
 get("/x").then().body("href", new ResponseAwareMatcher() {
                       public Matcher matcher(Response response) {
                           return equalTo("http://localhost:8080/" + response.path("userId"));
                       }
                  });
 
```
    Note that you can also use some of the predefined methods in RestAssuredMatchers.
    Specified by:
    
    body in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    body in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    key - The body path
    
    responseAwareMatcher - The ResponseAwareMatcher that creates the Hamcrest matcher.
    
    Returns:
    
    the response specification
    
    See Also:
    
    ValidatableResponseOptions.body(String, java.util.List, ResponseAwareMatcher), RestAssuredMatchers.endsWithPath(String), RestAssuredMatchers.startsWithPath(String), RestAssuredMatchers.containsPath(String), RestAssuredMatchers.equalToPath(String)
  - body
```
public ValidatableResponse body(String path,
                                List arguments,
                                org.hamcrest.Matcher matcher,
                                Object... additionalKeyMatcherPairs)
```
    Description copied from interface: ValidatableResponseOptions
    Same as ValidatableResponseOptions.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;
 get("/x").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:
```
 get("/x").then().
          root("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.
    Specified by:
    
    body in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    body in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    path - The body path
    
    arguments - The arguments to apply to the key
    
    matcher - The hamcrest matcher that must response body must match.
    
    additionalKeyMatcherPairs - Optionally additional hamcrest matchers that must return true.
    
    Returns:
    
    the response specification
    
    See Also:
    
    ValidatableResponseOptions.body(String, org.hamcrest.Matcher, Object...)
  - body
```
public ValidatableResponse body(List arguments,
                                org.hamcrest.Matcher matcher,
                                Object... additionalKeyMatcherPairs)
```
    Description copied from interface: ValidatableResponseOptions
    This as special kind of expectation that is mainly useful when you've specified a root path with an argument placeholder. For example:
```
  get(..).then().
            root("x.%s"). // Root path with a placeholder
            body(withArgs("firstName"), equalTo(..)).
            body(withArgs("lastName"), equalTo(..)).
 
```
    Note that this is the same as doing:
```
  get(..).then().
            root("x.%s"). // Root path with a placeholder
            content(withArgs("firstName"), equalTo(..)).
            content(withArgs("lastName"), equalTo(..)).
 
```
    Specified by:
    
    body in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    body in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    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.
    
    Returns:
    
    the response specification
    
    See Also:
    
    ValidatableResponseOptions.body(String, org.hamcrest.Matcher, Object...)
  - statusCode
```
public ValidatableResponse statusCode(org.hamcrest.Matcher expectedStatusCode)
```
    Description copied from interface: ValidatableResponseOptions
    Validate that the response status code matches the given Hamcrest matcher. E.g.
```
 get("/something").then().assertThat().statusCode(equalTo(200));
 
```
    Specified by:
    
    statusCode in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    statusCode in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    expectedStatusCode - The expected status code matcher.
    
    Returns:
    
    the response specification
  - statusCode
```
public ValidatableResponse statusCode(int expectedStatusCode)
```
    Description copied from interface: ValidatableResponseOptions
    Validate that the response status code matches an integer. E.g.
```
 get("/something").then().assertThat().statusCode(200);
 
```
    This is the same as:
```
 get("/something").then().assertThat().statusCode(equalTo(200));
 
```
    Specified by:
    
    statusCode in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    statusCode in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    expectedStatusCode - The expected status code.
    
    Returns:
    
    the response specification
  - statusLine
```
public ValidatableResponse statusLine(org.hamcrest.Matcher expectedStatusLine)
```
    Description copied from interface: ValidatableResponseOptions
    Validate that the response status line matches the given Hamcrest matcher. E.g.
```
 expect().statusLine(equalTo("No Content")).when().get("/something");
 
```
    Specified by:
    
    statusLine in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    statusLine in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    expectedStatusLine - The expected status line matcher.
    
    Returns:
    
    the response specification
  - statusLine
```
public ValidatableResponse statusLine(String expectedStatusLine)
```
    Description copied from interface: ValidatableResponseOptions
    Validate that the response status line matches the given String. E.g.
```
 expect().statusLine("No Content").when().get("/something");
 
```
    This is the same as:
```
 expect().statusLine(equalTo("No Content")).when().get("/something");
 
```
    Specified by:
    
    statusLine in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    statusLine in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    expectedStatusLine - The expected status line.
    
    Returns:
    
    the response specification
  - headers
```
public ValidatableResponse headers(Map expectedHeaders)
```
    Description copied from interface: ValidatableResponseOptions
    Validate that response headers matches those specified in a Map.
    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");

 get("/something").then().assertThat().headers(expectedHeaders);
 
```
    You can also use Hamcrest matchers:
```
 Map expectedHeaders = new HashMap();
 expectedHeaders.put("Content-Type", containsString("charset=UTF-8"));
 expectedHeaders.put("Content-Length", "160");

 get("/something").then().assertThat().headers(expectedHeaders);
 
```
    Specified by:
    
    headers in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    headers in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    expectedHeaders - The Map of expected response headers
    
    Returns:
    
    the response specification
  - headers
```
public ValidatableResponse headers(String firstExpectedHeaderName,
                                   Object firstExpectedHeaderValue,
                                   Object... expectedHeaders)
```
    Description copied from interface: ValidatableResponseOptions
    Validate that response headers matches the supplied headers and values.
    E.g. expect that the response of the GET request to "/something" contains header Pragma=no-cache and Content-Encoding=gzip:
```
 get("/something").then().assertThat().headers("Pragma", "no-cache", "Content-Encoding", "gzip");
 
```
    You can also use Hamcrest matchers:
```
 get("/something").then().assertThat().headers("Content-Type", containsString("application/json"), "Pragma", equalsTo("no-cache"));
 
```
    and you can even mix string matching and hamcrest matching:
```
 get("/something").then().assertThat().headers("Content-Type", containsString("application/json"), "Pragma", "no-cache");
 
```
    Specified by:
    
    headers in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    headers in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    firstExpectedHeaderName - The name of the first header
    
    firstExpectedHeaderValue - The value of the first header
    
    expectedHeaders - A list of expected "header name" - "header value" pairs.
    
    Returns:
    
    the response specification
  - header
```
public ValidatableResponse header(String headerName,
                                  org.hamcrest.Matcher expectedValueMatcher)
```
    Description copied from interface: ValidatableResponseOptions
    Validate that a response header matches the supplied header name and hamcrest matcher.
    E.g. expect that the response of the GET request to "/something" contains header Pragma=no-cache:
```
 get("/something").then().assertThat().header("Pragma", containsString("no"));
 
```
    You can also expect several headers:
```
 get("/something").then().assertThat().header("Pragma", equalsTo("no-cache")).and().header("Content-Encoding", containsString("zip"));
 
```
    Also take a look at ValidatableResponseOptions.headers(String, Object, Object...) )} for a short version of passing multiple headers.
    Specified by:
    
    header in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    header in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    headerName - The name of the expected header
    
    expectedValueMatcher - The Hamcrest matcher that must conform to the value
    
    Returns:
    
    the response specification
  - header
```
public ValidatableResponse header(String headerName,
                                  ResponseAwareMatcher r)
```
    Description copied from interface: ValidatableResponseOptions
    Compare a header in the response to something else available in the response.
    For example imagine that a POST to resource "/x" returns "201 Created" and sets a Location header that should end with "/x/{id}" where {id} is present in the response body:
```
 { "id" : 5 }
 
```
    To verify that the Location header ends with "/x/{id}" you can do like this:
```
 given().param("id", 1).body(..).post("/x").then().assertThat().header("Location", response -> endsWith("/x/" + response.path("id")));
 
```
    Specified by:
    
    header in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    header in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    headerName - The name of the expected header
    
    r - The Hamcrest matcher that must conform to the value
    
    Returns:
    
    the response specification
  - header
```
public ValidatableResponse header(String headerName,
                                  String expectedValue)
```
    Description copied from interface: ValidatableResponseOptions
    Validate that a response header matches the supplied name and value.
    E.g. expect that the response of the GET request to "/something" contains header Pragma=no-cache:
```
 get("/something").then().assertThat().header("Pragma", "no-cache");
 
```
    You can also expect several headers:
```
 get("/something").then().assertThat().header("Pragma", "no-cache").and().header("Content-Encoding", "gzip");
 
```
    Also take a look at ValidatableResponseOptions.headers(String, Object, Object...) for a short version of passing multiple headers.
    Specified by:
    
    header in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    header in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    headerName - The name of the expected header
    
    expectedValue - The value of the expected header
    
    Returns:
    
    the response specification
  - header
```
public ValidatableResponse header(String headerName,
                                  java.util.function.Function f,
                                  org.hamcrest.Matcher matcher)
```
    Description copied from interface: ValidatableResponseOptions
    Expect that a response header matches the supplied header name and hamcrest matcher using a mapping function.
    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));
 
```
    Specified by:
    
    header in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    header in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    headerName - The name of the expected header
    
    f - Map the header to another value type before exposing it to the Hamcrest matcher
    
    matcher - The Hamcrest matcher that must conform to the value
    
    Returns:
    
    the response specification
  - cookies
```
public ValidatableResponse cookies(Map expectedCookies)
```
    Description copied from interface: ValidatableResponseOptions
    Validate that response cookies matches those specified in a Map.
    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");

 get("/something").then().assertThat().cookies(expectedCookies);
 
```
    You can also use Hamcrest matchers:
```
 Map expectedCookies = new HashMap();
 expectedCookies.put("cookieName1", containsString("Value1"));
 expectedCookies.put("cookieName2", "cookieValue2");

 get("/something").then().assertThat().cookies(expectedCookies);
 
```
    Specified by:
    
    cookies in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    cookies in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    expectedCookies - A Map of expected response cookies
    
    Returns:
    
    the response specification
  - cookie
```
public ValidatableResponse cookie(String cookieName)
```
    Description copied from interface: ValidatableResponseOptions
    
    Validate that a cookie exist in the response, regardless of value (it may have no value at all).
    
    Specified by:
    
    cookie in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    cookie in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    cookieName - the cookie to validate that it exists
    
    Returns:
    
    the response specification
  - cookies
```
public ValidatableResponse cookies(String firstExpectedCookieName,
                                   Object firstExpectedCookieValue,
                                   Object... expectedCookieNameValuePairs)
```
    Description copied from interface: ValidatableResponseOptions
    Validate that response cookies matches the supplied cookie names and values.
    E.g. expect that the response of the GET request to "/something" contains cookies cookieName1=cookieValue1 and cookieName2=cookieValue2:
```
 get("/something").then().assertThat().cookies("cookieName1", "cookieValue1", "cookieName2", "cookieValue2");
 
```
    You can also use Hamcrest matchers:
```
 get("/something").then().assertThat().cookies("cookieName1", containsString("Value1"), "cookieName2", equalsTo("cookieValue2"));
 
```
    and you can even mix string matching and hamcrest matching:
```
 get("/something").then().assertThat().cookies("cookieName1", containsString("Value1"), "cookieName2", "cookieValue2");
 
```
    Specified by:
    
    cookies in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    cookies in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    firstExpectedCookieName - The name of the first cookie
    
    firstExpectedCookieValue - The value of the first cookie
    
    expectedCookieNameValuePairs - A list of expected "cookie name" - "cookie value" pairs.
    
    Returns:
    
    the response specification
  - cookie
```
public ValidatableResponse cookie(String cookieName,
                                  org.hamcrest.Matcher expectedValueMatcher)
```
    Description copied from interface: ValidatableResponseOptions
    Validate that a response cookie matches the supplied cookie name and hamcrest matcher.
    E.g. expect that the response of the GET request to "/something" contain cookie cookieName1=cookieValue1
```
 get("/something").then().assertThat().cookie("cookieName1", containsString("Value1"));
 
```
    You can also expect several cookies:
```
 get("/something").then().assertThat().cookie("cookieName1", equalsTo("cookieValue1")).and().cookie("cookieName2", containsString("Value2"));
 
```
    Also take a look at ValidatableResponseOptions.cookies(String, Object, Object...) for a short version of passing multiple cookies.
    Specified by:
    
    cookie in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    cookie in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    cookieName - The name of the expected cookie
    
    expectedValueMatcher - The Hamcrest matcher that must conform to the value
    
    Returns:
    
    the response specification
  - cookie
```
public ValidatableResponse cookie(String cookieName,
                                  Object expectedValue)
```
    Description copied from interface: ValidatableResponseOptions
    Validate that a response cookie matches the supplied name and value.
    E.g. expect that the response of the GET request to "/something" contain cookie cookieName1=cookieValue1:
```
 get("/something").then().assertThat().cookie("cookieName1", "cookieValue1");
 
```
    You can also expect several cookies:
```
 get("/something").then().assertThat().cookie("cookieName1", "cookieValue1").and().cookie("cookieName2", "cookieValue2");
 
```
    Also take a look at ValidatableResponseOptions.cookies(String, Object, Object...) for a short version of passing multiple cookies.
    Specified by:
    
    cookie in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    cookie in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    cookieName - The name of the expected cookie
    
    expectedValue - The value of the expected cookie
    
    Returns:
    
    the response specification
  - cookie
```
public ValidatableResponse cookie(String cookieName,
                                  DetailedCookieMatcher detailedCookieMatcher)
```
    Description copied from interface: ValidatableResponseOptions
    Validate that a detailed response cookie matches the supplied cookie name and hamcrest matcher (see DetailedCookieMatcher).
    E.g. expect that the response of the GET request to "/something" contain cookie cookieName1=cookieValue1
```
 get("/something").then().assertThat()
      .detailedCookie("cookieName1", detailedCookie().value("cookieValue1").secured(true));
 
```
    You can also expect several cookies:
```
 get("/something").then().assertThat().detailedCookie("cookieName1", detailedCookie().value("cookieValue1").secured(true))
      .and().detailedCookie("cookieName2", detailedCookie().value("cookieValue2").secured(false));
 
```
    Specified by:
    
    cookie in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    cookie in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    cookieName - The name of the expected cookie
    
    detailedCookieMatcher - The Hamcrest matcher that must conform to the cookie
    
    Returns:
    
    the response specification
  - rootPath
```
public ValidatableResponse rootPath(String rootPath)
```
    Description copied from interface: ValidatableResponseOptions
    Set the root path of the response body so that you don't need to write the entire path for each expectation. E.g. instead of writing:
```
 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 path and do:
```
 get(..).then().
            rootPath("x.y").
            body("firstName", is(..)).
            body("lastName", is(..)).
            body("age", is(..)).
            body("gender", is(..));
 
```
    Note that this method is exactly the same as ValidatableResponseOptions.root(String).
    Specified by:
    
    rootPath in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    rootPath in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    rootPath - The root path to use.
  - rootPath
```
public ValidatableResponse rootPath(String rootPath,
                                    List arguments)
```
    Description copied from interface: ValidatableResponseOptions
    
    Set the root path with arguments of the response body so that you don't need to write the entire path for each expectation.
    Note that this method is exactly the same as ValidatableResponseOptions.root(String, java.util.List).
    
    Specified by:
    
    rootPath in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    rootPath in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    rootPath - The root path to use.
    
    arguments - A list of arguments. The path and arguments follows the standard formatting syntax of Java.
    
    See Also:
    
    ValidatableResponseOptions.rootPath(String)
  - root
```
public ValidatableResponse root(String rootPath,
                                List arguments)
```
    Description copied from interface: ValidatableResponseOptions
    
    Set the root path with arguments of the response body so that you don't need to write the entire path for each expectation.
    Note that this method is exactly the same as ValidatableResponseOptions.rootPath(String, java.util.List).
    
    Specified by:
    
    root in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    root in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    rootPath - The root path to use.
    
    arguments - The list of substitution arguments. The path and arguments follows the standard formatting syntax of Java..
    
    See Also:
    
    ValidatableResponseOptions.rootPath(String)
  - root
```
public ValidatableResponse root(String rootPath)
```
    Description copied from interface: ValidatableResponseOptions
    Set the root path of the response body so that you don't need to write the entire path for each expectation. E.g. instead of writing:
```
 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:
```
 get(..).then().
          root("x.y").
          body("firstName", is(..)).
          body("lastName", is(..)).
          body("age", is(..)).
          body("gender", is(..)).
 
```
    Note that this method is exactly the same as ValidatableResponseOptions.rootPath(String) but slightly shorter.
    Specified by:
    
    root in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    root in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    rootPath - The root path to use.
  - noRoot
```
public ValidatableResponse noRoot()
```
    Description copied from interface: ValidatableResponseOptions
    Reset the root path of the response body so that you don't need to write the entire path for each expectation. For example:
```
 get(..).then().
          root("x.y").
          body("firstName", is(..)).
          body("lastName", is(..)).
          noRoot()
          body("z.something1", is(..)).
          body("w.something2", is(..));
 
```
    This is the same as calling rootPath("") but more expressive. Note that this method is exactly the same as ValidatableResponseOptions.noRootPath() but slightly shorter.
    Specified by:
    
    noRoot in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    noRoot in class ValidatableResponseOptionsImpl
    
    See Also:
    
    ValidatableResponseOptions.root(String)
  - noRootPath
```
public ValidatableResponse noRootPath()
```
    Description copied from interface: ValidatableResponseOptions
    Reset the root path of the response body so that you don't need to write the entire path for each expectation. For example:
```
 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 more expressive. Note that this method is exactly the same as ValidatableResponseOptions.noRoot() but slightly more expressive.
    Specified by:
    
    noRootPath in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    noRootPath in class ValidatableResponseOptionsImpl
    
    See Also:
    
    ValidatableResponseOptions.rootPath(String)
  - appendRootPath
```
public ValidatableResponse appendRootPath(String pathToAppend)
```
    Description copied from interface: ValidatableResponseOptions
    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. E.g. instead of writing:
```
 get(..).then().
          root("x.y").
          body("age", is(..)).
          body("gender", is(..)).
          body("name.firstName", is(..)).
          body("name.lastName", is(..));
 
```
    you can use a append root and do:
```
 get(..).then().
          root("x.y").
          body("age", is(..)).
          body("gender", is(..)).
          appendRoot("name").
          body("firstName", is(..)).
          body("lastName", is(..));
 
```
    Specified by:
    
    appendRootPath in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    appendRootPath in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    pathToAppend - The root path to append.
  - appendRootPath
```
public ValidatableResponse appendRootPath(String pathToAppend,
                                          List arguments)
```
    Description copied from interface: ValidatableResponseOptions
    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. This is mainly useful when you have parts of the path defined in variables. E.g. instead of writing:
```
 String namePath = "name";
 get(..).then().
           root("x.y").
           body("age", is(..)).
           body("gender", is(..)).
           body(namePath + "first", is(..)).
           body(namePath + "last", is(..)).
 
```
    you can use a append root and do:
```
 String namePath = "name";
 get(..).then().
          root("x.y").
          body("age", is(..)).
          body("gender", is(..)).
          appendRoot("%s", withArgs(namePath)).
          body("first", is(..)).
          body("last", is(..)).
 
```
    Specified by:
    
    appendRootPath in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    appendRootPath in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    pathToAppend - The root path to append. The path and arguments follows the standard formatting syntax of Java.
  - detachRootPath
```
public ValidatableResponse detachRootPath(String pathToDetach)
```
    Description copied from interface: ValidatableResponseOptions
    Detach the given path from the root path. E.g. instead of writing:
```
 when().
          get(..);
 then().
          root("x.y").
          body("age", is(..)).
          body("gender", is(..)).
          root("x").
          body("firstName", is(..)).
          body("lastName", is(..)).
 
```
    you can use a append root and do:
```
 when().
          get(..);
 then().
          root("x.y").
          body("age", is(..)).
          body("gender", is(..)).
          detachRoot("y").
          body("firstName", is(..)).
          body("lastName", is(..)).
 
```
    Specified by:
    
    detachRootPath in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    detachRootPath in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    pathToDetach - The root path to detach.
  - contentType
```
public ValidatableResponse contentType(ContentType contentType)
```
    Description copied from interface: ValidatableResponseOptions
    
    Set the response content type to be contentType.
    Note that this will affect the way the response is decoded. E,g. if you can't use JSON/XML matching (see e.g. ValidatableResponseOptions.body(String, org.hamcrest.Matcher, Object...)) if you specify a content-type of "text/plain". If you don't specify the response content type REST Assured will automatically try to figure out which content type to use.
    
    Specified by:
    
    contentType in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    contentType in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    contentType - The content type of the response.
    
    Returns:
    
    the response specification
  - contentType
```
public ValidatableResponse contentType(String contentType)
```
    Description copied from interface: ValidatableResponseOptions
    
    Set the response content type to be contentType.
    Note that this will affect the way the response is decoded. E,g. if you can't use JSON/XML matching (see e.g. ValidatableResponseOptions.body(String, org.hamcrest.Matcher, Object...)) if you specify a content-type of "text/plain". If you don't specify the response content type REST Assured will automatically try to figure out which content type to use.
    
    Specified by:
    
    contentType in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    contentType in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    contentType - The content type of the response.
    
    Returns:
    
    the response specification
  - contentType
```
public ValidatableResponse contentType(org.hamcrest.Matcher contentType)
```
    Description copied from interface: ValidatableResponseOptions
    
    Validate the response content type to be contentType.
    
    Specified by:
    
    contentType in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    contentType in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    contentType - The expected content type of the response.
    
    Returns:
    
    the response specification
  - body
```
public ValidatableResponse body(org.hamcrest.Matcher matcher,
                                org.hamcrest.Matcher... additionalMatchers)
```
    Description copied from interface: ValidatableResponseOptions
    Validate that the response body conforms to one or more Hamcrest matchers. E.g.
```
 // Validate that the response body (content) contains the string "winning-numbers"
 get("/lotto").then().assertThat().body(containsString("winning-numbers"));

 // Validate that the response body (content) contains the string "winning-numbers" and "winners"
 get("/lotto").then().assertThat().body(containsString("winning-numbers"), containsString("winners"));
 
```
    Specified by:
    
    body in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    body in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    matcher - The hamcrest matcher that must response body must match.
    
    additionalMatchers - Optionally additional hamcrest matchers that must return true.
    
    Returns:
    
    the response specification
  - body
```
public ValidatableResponse body(String path,
                                org.hamcrest.Matcher matcher,
                                Object... additionalKeyMatcherPairs)
```
    Description copied from interface: ValidatableResponseOptions
    Validate that the JSON or XML response body conforms to one or more Hamcrest matchers.
    
    JSON example
    
    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:
```
 get("/lotto").then().assertThat().body("lotto.lottoId", equalTo(5));
 
```
    You can also verify that e.g. one of the the winning numbers is 45.
```
 get("/lotto").then().assertThat().body("lotto.winning-numbers", hasItem(45));
 
```
    Or both at the same time:
```
 get("/lotto").then().assertThat().body("lotto.lottoId", equalTo(5)).and().body("lotto.winning-numbers", hasItem(45));
 
```
    or a slightly short version:
```
 get("/lotto").then().assertThat().body("lotto.lottoId", equalTo(5), "lotto.winning-numbers", hasItem(45));
 
```
    XML example
    
    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:
```
 get("/xml").then().assertThat().body("greeting.firstName", equalTo("John"));
 
```
    To verify both the first name and last name you can do like this:
```
 get("/xml").then().assertThat().body("greeting.firstName", equalTo("John")).and().body("greeting.lastName", equalTo("Doe"));
 
```
    Or the slightly shorter version of:
```
 get("/xml").then().assertThat().body("greeting.firstName", equalTo("John"), "greeting.lastName", equalTo("Doe"));
 
```
    Notes
    
    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.
    Specified by:
    
    body in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    body in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    path - The body path
    
    matcher - The hamcrest matcher that must response body must match.
    
    additionalKeyMatcherPairs - Optionally additional hamcrest matchers that must return true.
    
    Returns:
    
    the response specification
  - content
```
public ValidatableResponse content(String path,
                                   List arguments,
                                   org.hamcrest.Matcher matcher,
                                   Object... additionalKeyMatcherPairs)
```
    Overrides:
    
    content in class ValidatableResponseOptionsImpl
  - extract
```
public ExtractableResponse extract()
```
    Description copied from interface: ValidatableResponseOptions
    Extract values from the response or return the response instance itself. This is useful for example if you want to use values from the response in sequent requests. For example given that the resource title returns the following JSON
```
 {
     "title" : "My Title",
      "_links": {
              "self": { "href": "/title" },
              "next": { "href": "/title?page=2" }
           }
 }
 
```
    and you want to validate that content type is equal to JSON and the title is equal to My Title but you also want to extract the link to the "next" title to use that in a subsequent request. This is how:
```
 String nextTitleLink =
 given().
         param("param_name", "param_value").
 when().
         get("/title").
 then().
         contentType(JSON).
         body("title", equalTo("My Title")).
 extract().
         path("_links.next.href");

 get(nextTitleLink). ..
 
```
    Specified by:
    
    extract in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    extract in class ValidatableResponseOptionsImpl
    
    Returns:
    
    An instance of ExtractableResponse.
  - log
```
public ValidatableResponseLogSpec log()
```
    Description copied from interface: ValidatableResponseOptions
    
    Returns the ValidatableResponseLogSpec that allows you to log different parts of the Response. This is mainly useful for debug purposes when writing your tests.
    
    Specified by:
    
    log in interface ValidatableResponseOptions<ValidatableResponse,Response>
    
    Overrides:
    
    log in class ValidatableResponseOptionsImpl
    
    Returns:
    
    the validatable response log specification
  - status
```
public ValidatableResponse status()
```
    Description copied from interface: ValidatableResponseLogSpec
    
    Logs only the status line (includes the status code)
    
    Specified by:
    
    status in interface ValidatableResponseLogSpec
    
    Overrides:
    
    status in class ValidatableResponseOptionsImpl
    
    Returns:
    
    The validatable response specification
  - ifError
```
public ValidatableResponse ifError()
```
    Description copied from interface: ValidatableResponseLogSpec
    
    Logs everything only if an error occurs (status code >= 400).
    
    Specified by:
    
    ifError in interface ValidatableResponseLogSpec
    
    Overrides:
    
    ifError in class ValidatableResponseOptionsImpl
    
    Returns:
    
    The validatable response specification
  - ifStatusCodeIsEqualTo
```
public ValidatableResponse ifStatusCodeIsEqualTo(int statusCode)
```
    Description copied from interface: ValidatableResponseLogSpec
    
    Logs everything only if if the status code is equal to statusCode.
    
    Specified by:
    
    ifStatusCodeIsEqualTo in interface ValidatableResponseLogSpec
    
    Overrides:
    
    ifStatusCodeIsEqualTo in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    statusCode - The status code
    
    Returns:
    
    The validatable response specification
  - ifStatusCodeMatches
```
public ValidatableResponse ifStatusCodeMatches(org.hamcrest.Matcher matcher)
```
    Description copied from interface: ValidatableResponseLogSpec
    
    Logs everything only if if the status code matches the supplied matcher
    
    Specified by:
    
    ifStatusCodeMatches in interface ValidatableResponseLogSpec
    
    Overrides:
    
    ifStatusCodeMatches in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    matcher - The hamcrest matcher
    
    Returns:
    
    The validatable response specification
  - body
```
public ValidatableResponse body()
```
    Description copied from interface: ValidatableResponseLogSpec
    
    Logs only the content of the body. The body will be pretty-printed by default if content-type is either XML, JSON or HTML.
    
    Specified by:
    
    body in interface ValidatableResponseLogSpec
    
    Overrides:
    
    body in class ValidatableResponseOptionsImpl
    
    Returns:
    
    The specification
  - body
```
public ValidatableResponse body(boolean shouldPrettyPrint)
```
    Description copied from interface: ValidatableResponseLogSpec
    
    Logs only the content of the body and pretty-print the body if specified. Note that pretty-printing can only take place if the content-type is either XML, JSON or HTML.
    
    Specified by:
    
    body in interface ValidatableResponseLogSpec
    
    Overrides:
    
    body in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    shouldPrettyPrint - true if the body should be pretty-printed, false otherwise.
    
    Returns:
    
    The specification
  - all
```
public ValidatableResponse all(boolean shouldPrettyPrint)
```
    Description copied from interface: ValidatableResponseLogSpec
    
    Logs everything in the response, including e.g. headers, cookies, body with the option to pretty-print the body if the content-type is either XML, JSON or HTML..
    
    Specified by:
    
    all in interface ValidatableResponseLogSpec
    
    Overrides:
    
    all in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    shouldPrettyPrint - true if the body should be pretty-printed, false otherwise.
    
    Returns:
    
    The specification
  - everything
```
public ValidatableResponse everything()
```
    Description copied from interface: ValidatableResponseLogSpec
    
    Logs everything in the response, including e.g. headers, cookies, body. Pretty-prints the body if content-type is either either XML, JSON or HTML..
    
    Specified by:
    
    everything in interface ValidatableResponseLogSpec
    
    Overrides:
    
    everything in class ValidatableResponseOptionsImpl
    
    Returns:
    
    The specification
  - everything
```
public ValidatableResponse everything(boolean shouldPrettyPrint)
```
    Description copied from interface: ValidatableResponseLogSpec
    
    * Logs everything in the response, including e.g. headers, cookies, body with the option to pretty-print the body if the content-type is either XML, JSON or HTML..
    
    Specified by:
    
    everything in interface ValidatableResponseLogSpec
    
    Overrides:
    
    everything in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    shouldPrettyPrint - true if the body should be pretty-printed, false otherwise.
    
    Returns:
    
    The specification
  - headers
```
public ValidatableResponse headers()
```
    Description copied from interface: ValidatableResponseLogSpec
    
    Logs only the headers.
    
    Specified by:
    
    headers in interface ValidatableResponseLogSpec
    
    Overrides:
    
    headers in class ValidatableResponseOptionsImpl
    
    Returns:
    
    The specification
  - cookies
```
public ValidatableResponse cookies()
```
    Description copied from interface: ValidatableResponseLogSpec
    
    Logs only the cookies.
    
    Specified by:
    
    cookies in interface ValidatableResponseLogSpec
    
    Overrides:
    
    cookies in class ValidatableResponseOptionsImpl
    
    Returns:
    
    The specification
  - ifValidationFails
```
public ValidatableResponse ifValidationFails()
```
    Description copied from interface: ValidatableResponseLogSpec
    
    Logs everything if a test validation fails.
    
    Specified by:
    
    ifValidationFails in interface ValidatableResponseLogSpec
    
    Overrides:
    
    ifValidationFails in class ValidatableResponseOptionsImpl
    
    Returns:
    
    The specification
  - ifValidationFails
```
public ValidatableResponse ifValidationFails(LogDetail logDetail)
```
    Description copied from interface: ValidatableResponseLogSpec
    
    Logs with the supplied log detail only if the validation fails.
    
    Specified by:
    
    ifValidationFails in interface ValidatableResponseLogSpec
    
    Overrides:
    
    ifValidationFails in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    logDetail - The log detail
    
    Returns:
    
    The specification
  - ifValidationFails
```
public ValidatableResponse ifValidationFails(LogDetail logDetail,
                                             boolean shouldPrettyPrint)
```
    Description copied from interface: ValidatableResponseLogSpec
    
    Logs all parameters only if the validations fail.
    
    Specified by:
    
    ifValidationFails in interface ValidatableResponseLogSpec
    
    Overrides:
    
    ifValidationFails in class ValidatableResponseOptionsImpl
    
    Parameters:
    
    logDetail - The log detail
    
    shouldPrettyPrint - true if the body should be pretty-printed, false otherwise.
    
    Returns:
    
    The specification
  - getMetaClass
```
public groovy.lang.MetaClass getMetaClass()
```
    Specified by:
    
    getMetaClass in interface groovy.lang.GroovyObject
  - setMetaClass
```
public void setMetaClass(groovy.lang.MetaClass mc)
```
    Specified by:
    
    setMetaClass in interface groovy.lang.GroovyObject
  - invokeMethod
```
public Object invokeMethod(String method,
                           Object arguments)
```
    Specified by:
    
    invokeMethod in interface groovy.lang.GroovyObject
  - getProperty
```
public Object getProperty(String property)
```
    Specified by:
    
    getProperty in interface groovy.lang.GroovyObject
  - setProperty
```
public void setProperty(String property,
                        Object value)
```
    Specified by:
    
    setProperty in interface groovy.lang.GroovyObject

Class ValidatableResponseImpl

Field Summary

Fields inherited from class io.restassured.internal.ValidatableResponseOptionsImpl

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface io.restassured.response.ValidatableResponseOptions

Constructor Detail

ValidatableResponseImpl

Method Detail

originalResponse

time

time

defaultParser

parser

spec

assertThat

using

and

all

body

body

body

body

body

statusCode

statusCode

statusLine

statusLine

headers

headers

header

header

header

header

cookies

cookie

cookies

cookie

cookie

cookie

rootPath

rootPath

root

root

noRoot

noRootPath

appendRootPath

appendRootPath

detachRootPath

contentType

contentType

contentType

body

body

JSON example

XML example

Notes

content

extract

log

status

ifError

ifStatusCodeIsEqualTo

ifStatusCodeMatches

body

body

all

everything

everything

headers

cookies

ifValidationFails

ifValidationFails

ifValidationFails

getMetaClass

setMetaClass

invokeMethod

getProperty

setProperty