RestAssuredMockMvc (spring-mock-mvc 4.2.0 API)

java.lang.Object
- io.restassured.module.mockmvc.RestAssuredMockMvc

```
public class RestAssuredMockMvc
extends Object
```
The Spring MVC module's equivalent of RestAssured. This is the starting point of the DSL.
Note that some Javadoc is copied from Spring MVC's test documentation.

Field Summary

Fields
Modifier and Type	Field and Description
`static MockMvcAuthenticationScheme`	`authentication` Defines a global authentication scheme that'll be used for all requests (if not overridden).
`static String`	`basePath` The base path that's used by REST assured when making requests.
`static RestAssuredMockMvcConfig`	`config` Define a REST Assured Mock Mvc configuration.
`static MockMvcRequestSpecification`	`requestSpecification` Specify a default request specification that will be sent with each request.
`static io.restassured.specification.ResponseSpecification`	`responseSpecification` Specify a default response specification that will be sent with each request.

Constructor Summary

Constructors
Constructor and Description

RestAssuredMockMvc()

Constructors
Constructor and Description
`RestAssuredMockMvc()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static MockMvcAuthenticationScheme`	`authentication(Object authentication)` Authenticate using the supplied authentication instance (`org.springframework.security.core.Authentication` from Spring Security).
`static RestAssuredMockMvcConfig`	`config()`
`static MockMvcResponse`	`delete()` Perform a DELETE request to the statically configured base path.
`static MockMvcResponse`	`delete(String path, Map<String,?> pathParams)` Perform a DELETE request to a `path`.
`static MockMvcResponse`	`delete(String path, Object... pathParams)` Perform a DELETE request to a `path`.
`static MockMvcResponse`	`delete(URI uri)` Perform a DELETE request to a `uri`.
`static MockMvcResponse`	`delete(URL url)` Perform a DELETE request to a `url`.
`static void`	`enableLoggingOfRequestAndResponseIfValidationFails()` Enable logging of both the request and the response if REST Assureds test validation fails with log detail equal to `LogDetail.ALL`.
`static void`	`enableLoggingOfRequestAndResponseIfValidationFails(io.restassured.filter.log.LogDetail logDetail)` Enable logging of both the request and the response if REST Assureds test validation fails with the specified log detail.
`static MockMvcResponse`	`get()` Perform a GET request to the statically configured base path.
`static MockMvcResponse`	`get(String path, Map<String,?> pathParams)` Perform a GET request to a `path`.
`static MockMvcResponse`	`get(String path, Object... pathParams)` Perform a GET request to a `path`.
`static MockMvcResponse`	`get(URI uri)` Perform a GET request to a `uri`.
`static MockMvcResponse`	`get(URL url)` Perform a GET request to a `url`.
`static MockMvcRequestSpecification`	`given()` This is usually the entry-point of the API if you need to specify parameters or a body in the request.
`static MockMvcResponse`	`head()` Perform a HEAD request to the statically configured base path.
`static MockMvcResponse`	`head(String path, Map<String,?> pathParams)` Perform a HEAD request to a `path`.
`static MockMvcResponse`	`head(String path, Object... pathParams)` Perform a HEAD request to a `path`.
`static MockMvcResponse`	`head(URI uri)` Perform a HEAD request to a `uri`.
`static MockMvcResponse`	`head(URL url)` Perform a HEAD request to a `url`.
`static void`	`mockMvc(org.springframework.test.web.servlet.MockMvc mockMvc)` Set a `MockMvc` instance that REST Assured will use when making requests unless overwritten by a `MockMvcRequestSpecification`.
`static MockMvcResponse`	`options()` Perform a OPTIONS request to the statically configured base path.
`static MockMvcResponse`	`options(String path, Map<String,?> pathParams)` Perform a OPTIONS request to a `path`.
`static MockMvcResponse`	`options(String path, Object... pathParams)` Perform a OPTIONS request to a `path`.
`static MockMvcResponse`	`options(URI uri)` Perform a OPTIONS request to a `uri`.
`static MockMvcResponse`	`options(URL url)` Perform a OPTIONS request to a `url`.
`static MockMvcResponse`	`patch()` Perform a PATCH request to the statically configured base path.
`static MockMvcResponse`	`patch(String path, Map<String,?> pathParams)` Perform a PATCH request to a `path`.
`static MockMvcResponse`	`patch(String path, Object... pathParams)` Perform a PATCH request to a `path`.
`static MockMvcResponse`	`patch(URI uri)` Perform a PATCH request to a `uri`.
`static MockMvcResponse`	`patch(URL url)` Perform a PATCH request to a `url`.
`static MockMvcResponse`	`post()` Perform a POST request to the statically configured base path.
`static MockMvcResponse`	`post(String path, Map<String,?> pathParams)` Perform a POST request to a `path`.
`static MockMvcResponse`	`post(String path, Object... pathParams)` Perform a POST request to a `path`.
`static MockMvcResponse`	`post(URI uri)` Perform a POST request to a `uri`.
`static MockMvcResponse`	`post(URL url)` Perform a POST request to a `url`.
`static List<org.springframework.test.web.servlet.request.RequestPostProcessor>`	`postProcessors()`
`static void`	`postProcessors(org.springframework.test.web.servlet.request.RequestPostProcessor postProcessor, org.springframework.test.web.servlet.request.RequestPostProcessor... additionalPostProcessors)` Assign one or more `ResultHandler` that'll be executes after a request has been made.
`static MockMvcAuthenticationScheme`	`principal(Object principal)` Authenticate using the given principal.
`static MockMvcAuthenticationScheme`	`principal(Principal principal)` Authenticate using the given principal.
`static MockMvcAuthenticationScheme`	`principalWithCredentials(Object principal, Object credentials, String... authorities)` Authenticate using the given principal and credentials.
`static MockMvcResponse`	`put()` Perform a PUT request to the statically configured base path.
`static MockMvcResponse`	`put(String path, Object... pathParams)` Perform a PUT request to a `path`.
`static MockMvcResponse`	`put(URI uri)` Perform a PUT request to a `uri`.
`static MockMvcResponse`	`put(URL url)` Perform a PUT request to a `url`.
`static MockMvcResponse`	`request(io.restassured.http.Method method)` Perform a request to the pre-configured path (by default `http://localhost:8080`).
`static MockMvcResponse`	`request(io.restassured.http.Method method, String path, Object... pathParams)` Perform a HTTP request to a `path`.
`static MockMvcResponse`	`request(io.restassured.http.Method method, URI uri)` Perform a request to a `uri`.
`static MockMvcResponse`	`request(io.restassured.http.Method method, URL url)` Perform a request to a `url`.
`static MockMvcResponse`	`request(String method)` Perform a custom HTTP request to the pre-configured path (by default `http://localhost:8080`).
`static MockMvcResponse`	`request(String method, String path, Object... pathParams)` Perform a custom HTTP request to a `path`.
`static MockMvcResponse`	`request(String method, URI uri)` Perform a custom HTTP request to a `uri`.
`static MockMvcResponse`	`request(String method, URL url)` Perform a custom HTTP request to a `url`.
`static void`	`reset()` Reset all static configurations to their default values.
`static List<org.springframework.test.web.servlet.ResultHandler>`	`resultHandlers()`
`static void`	`resultHandlers(org.springframework.test.web.servlet.ResultHandler resultHandler, org.springframework.test.web.servlet.ResultHandler... resultHandlers)` Assign one or more `ResultHandler` that'll be executes after a request has been made.
`static void`	`standaloneSetup(org.springframework.test.web.servlet.MockMvcBuilder builder)` Build a `MockMvc` by using a provided `AbstractMockMvcBuilder` for configuring Spring MVC infrastructure programmatically.
`static void`	`standaloneSetup(Object... controllersOrMockMvcConfigurers)` Build a `MockMvc` by registering one or more `@Controller`'s instances and configuring Spring MVC infrastructure programmatically.
`static void`	`webAppContextSetup(org.springframework.web.context.WebApplicationContext context, org.springframework.test.web.servlet.setup.MockMvcConfigurer... mockMvcConfigurers)` Build a `MockMvc` using the given, fully initialized, i.e.
`static MockMvcRequestSender`	`when()` This is usually the entry-point of the API if you need to specify parameters or a body in the request.
`static MockMvcRequestSpecification`	`with()` This is usually the entry-point of the API if you need to specify parameters or a body in the request.
`static MockMvcAuthenticationScheme`	`with(org.springframework.test.web.servlet.request.RequestPostProcessor requestPostProcessor, org.springframework.test.web.servlet.request.RequestPostProcessor... additionalRequestPostProcessor)` Authenticate using a `RequestPostProcessor`.

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

- Field Detail
  - config
```
public static RestAssuredMockMvcConfig config
```
    Define a REST Assured Mock Mvc configuration. E.g.
```
 given().config(newConfig().logConfig(new LogConfig(captor, true))). ..
 
```
    newConfig() can be statically imported from RestAssuredMockMvcConfig.
  - requestSpecification
```
public static MockMvcRequestSpecification requestSpecification
```
    Specify a default request specification that will be sent with each request. E,g.
```
 RestAssuredMockMvc.requestSpecification = new MockMvcRequestSpecBuilder().addParam("parameter1", "value1").build();
 
```
    means that for each request by Rest Assured "parameter1" will be equal to "value1".
  - responseSpecification
```
public static io.restassured.specification.ResponseSpecification responseSpecification
```
    Specify a default response specification that will be sent with each request. E,g.
```
 RestAssuredMockMvc.responseSpecification = new ResponseSpecBuilder().expectStatusCode(200).build();
 
```
    means that for each response Rest Assured will assert that the status code is equal to 200.
  - basePath
```
public static String basePath
```
    The base path that's used by REST assured when making requests. The base path is prepended to the request path. Default value is /.
  - authentication
```
public static MockMvcAuthenticationScheme authentication
```
    Defines a global authentication scheme that'll be used for all requests (if not overridden). Usage example:
```
 RestAssured.authentication = principal(myPrincipal);
 
```
    See Also:
    
    principal(java.security.Principal), principal(Object), principalWithCredentials(Object, Object, String...), authentication(Object)
- Constructor Detail
  - RestAssuredMockMvc
```
public RestAssuredMockMvc()
```
- Method Detail
  - mockMvc
```
public static void mockMvc(org.springframework.test.web.servlet.MockMvc mockMvc)
```
    Set a MockMvc instance that REST Assured will use when making requests unless overwritten by a MockMvcRequestSpecification.
    
    Parameters:
    
    mockMvc - The MockMvc instance to use.
  - given
```
public static MockMvcRequestSpecification given()
```
    This is usually the entry-point of the API if you need to specify parameters or a body in the request. For example:
```
 given().
         param("x", "y").
 when().
         get("/something").
 then().
        statusCode(200).
        body("x.y", notNullValue());
 
```
    Note that this method is the same as with() but with another syntax.
    Returns:
    
    A MockMvcRequestSpecification.
  - with
```
public static MockMvcRequestSpecification with()
```
    This is usually the entry-point of the API if you need to specify parameters or a body in the request. For example:
```
 given().
         param("x", "y").
 when().
         get("/something").
 then().
        statusCode(200).
        body("x.y", notNullValue());
 
```
    Note that this method is the same as given() but with another syntax.
    Returns:
    
    A MockMvcRequestSpecification.
  - when
```
public static MockMvcRequestSender when()
```
    This is usually the entry-point of the API if you need to specify parameters or a body in the request. For example:
```
 when().
        get("/x").
 then().
        body("x.y.z1", equalTo("Z1")).
        body("x.y.z2", equalTo("Z2"));
 
```
    Note that if you need to add parameters, headers, cookies or other request properties use the given() method.
    Returns:
    
    A request sender interface that let's you call resources on the server
  - standaloneSetup
```
public static void standaloneSetup(Object... controllersOrMockMvcConfigurers)
```
    Build a MockMvc by registering one or more @Controller's instances and configuring Spring MVC infrastructure programmatically. This allows full control over the instantiation and initialization of controllers, and their dependencies, similar to plain unit tests while also making it possible to test one controller at a time.
    
    When this option is used, the minimum infrastructure required by the org.springframework.web.servlet.DispatcherServlet to serve requests with annotated controllers is automatically created, and can be customized, resulting in configuration that is equivalent to what the MVC Java configuration provides except using builder style methods.
    
    If the Spring MVC configuration of an application is relatively straight-forward, for example when using the MVC namespace or the MVC Java config, then using this builder might be a good option for testing a majority of controllers. A much smaller number of tests can be used to focus on testing and verifying the actual Spring MVC configuration.
    
    Parameters:
    
    controllersOrMockMvcConfigurers - one or more @Controller's to test as well as @{link MockMvcConfigurer}'s to apply
  - standaloneSetup
```
public static void standaloneSetup(org.springframework.test.web.servlet.MockMvcBuilder builder)
```
    Build a MockMvc by using a provided AbstractMockMvcBuilder for configuring Spring MVC infrastructure programmatically. This allows full control over the instantiation and initialization of controllers, and their dependencies, similar to plain unit tests while also making it possible to test one controller at a time.
    
    If the Spring MVC configuration of an application is relatively straight-forward, for example when using the MVC namespace or the MVC Java config, then using this builder might be a good option for testing a majority of controllers. A much smaller number of tests can be used to focus on testing and verifying the actual Spring MVC configuration.
    
    Parameters:
    
    builder - AbstractMockMvcBuilder to build the MVC mock
  - webAppContextSetup
```
public static void webAppContextSetup(org.springframework.web.context.WebApplicationContext context,
                                      org.springframework.test.web.servlet.setup.MockMvcConfigurer... mockMvcConfigurers)
```
    Build a MockMvc using the given, fully initialized, i.e. refreshed, WebApplicationContext and assign it to REST Assured. The org.springframework.web.servlet.DispatcherServlet will use the context to discover Spring MVC infrastructure and application controllers in it. The context must have been configured with a ServletContext.
    
    Parameters:
    
    context - The web application context to use
    
    mockMvcConfigurers - MockMvcConfigurer's to be applied when creating a MockMvc instance of this WebApplicationContext (optional)
  - resultHandlers
```
public static void resultHandlers(org.springframework.test.web.servlet.ResultHandler resultHandler,
                                  org.springframework.test.web.servlet.ResultHandler... resultHandlers)
```
    Assign one or more ResultHandler that'll be executes after a request has been made.
    
    Parameters:
    
    resultHandler - The result handler
    
    resultHandlers - Additional result handlers (optional)
  - resultHandlers
```
public static List<org.springframework.test.web.servlet.ResultHandler> resultHandlers()
```
    Returns:
    
    The defined list of result handlers
  - postProcessors
```
public static void postProcessors(org.springframework.test.web.servlet.request.RequestPostProcessor postProcessor,
                                  org.springframework.test.web.servlet.request.RequestPostProcessor... additionalPostProcessors)
```
    Assign one or more ResultHandler that'll be executes after a request has been made.
    Note that it's recommended to use with(RequestPostProcessor, RequestPostProcessor...) instead of this method when setting authentication/authorization based RequestPostProcessors.
    
    Parameters:
    
    postProcessor - a post-processor to add
    
    additionalPostProcessors - Additional post-processors to add
    
    See Also:
    
    MockMvcRequestSpecification.postProcessors(RequestPostProcessor, RequestPostProcessor...)
  - postProcessors
```
public static List<org.springframework.test.web.servlet.request.RequestPostProcessor> postProcessors()
```
    Returns:
    
    The defined list of request post processors
  - reset
```
public static void reset()
```
    Reset all static configurations to their default values.
  - get
```
public static MockMvcResponse get(String path,
                                  Object... pathParams)
```
    Perform a GET request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do get("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);.
    
    Returns:
    
    The response of the GET request.
  - get
```
public static MockMvcResponse get(String path,
                                  Map<String,?> pathParams)
```
    Perform a GET request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters.
    
    Returns:
    
    The response of the GET request.
  - post
```
public static MockMvcResponse post(String path,
                                   Object... pathParams)
```
    Perform a POST request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do post("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);.
    
    Returns:
    
    The response of the request.
  - post
```
public static MockMvcResponse post(String path,
                                   Map<String,?> pathParams)
```
    Perform a POST request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters.
    
    Returns:
    
    The response of the request.
  - put
```
public static MockMvcResponse put(String path,
                                  Object... pathParams)
```
    Perform a PUT request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do put("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);.
    
    Returns:
    
    The response of the request.
  - delete
```
public static MockMvcResponse delete(String path,
                                     Object... pathParams)
```
    Perform a DELETE request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do delete("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);.
    
    Returns:
    
    The response of the request.
  - delete
```
public static MockMvcResponse delete(String path,
                                     Map<String,?> pathParams)
```
    Perform a DELETE request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters.
    
    Returns:
    
    The response of the request.
  - head
```
public static MockMvcResponse head(String path,
                                   Object... pathParams)
```
    Perform a HEAD request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do head("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);.
    
    Returns:
    
    The response of the request.
  - head
```
public static MockMvcResponse head(String path,
                                   Map<String,?> pathParams)
```
    Perform a HEAD request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters.
    
    Returns:
    
    The response of the request.
  - patch
```
public static MockMvcResponse patch(String path,
                                    Object... pathParams)
```
    Perform a PATCH request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do head("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);.
    
    Returns:
    
    The response of the request.
  - patch
```
public static MockMvcResponse patch(String path,
                                    Map<String,?> pathParams)
```
    Perform a PATCH request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters.
    
    Returns:
    
    The response of the request.
  - options
```
public static MockMvcResponse options(String path,
                                      Object... pathParams)
```
    Perform a OPTIONS request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do head("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);.
    
    Returns:
    
    The response of the request.
  - options
```
public static MockMvcResponse options(String path,
                                      Map<String,?> pathParams)
```
    Perform a OPTIONS request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters.
    
    Returns:
    
    The response of the request.
  - get
```
public static MockMvcResponse get(URI uri)
```
    Perform a GET request to a uri.
    
    Parameters:
    
    uri - The uri to send the request to.
    
    Returns:
    
    The response of the GET request.
  - post
```
public static MockMvcResponse post(URI uri)
```
    Perform a POST request to a uri.
    
    Parameters:
    
    uri - The uri to send the request to.
    
    Returns:
    
    The response of the request.
  - put
```
public static MockMvcResponse put(URI uri)
```
    Perform a PUT request to a uri.
    
    Parameters:
    
    uri - The uri to send the request to.
    
    Returns:
    
    The response of the request.
  - delete
```
public static MockMvcResponse delete(URI uri)
```
    Perform a DELETE request to a uri.
    
    Parameters:
    
    uri - The uri to send the request to.
    
    Returns:
    
    The response of the request.
  - head
```
public static MockMvcResponse head(URI uri)
```
    Perform a HEAD request to a uri.
    
    Parameters:
    
    uri - The uri to send the request to.
    
    Returns:
    
    The response of the request.
  - patch
```
public static MockMvcResponse patch(URI uri)
```
    Perform a PATCH request to a uri.
    
    Parameters:
    
    uri - The uri to send the request to.
    
    Returns:
    
    The response of the request.
  - options
```
public static MockMvcResponse options(URI uri)
```
    Perform a OPTIONS request to a uri.
    
    Parameters:
    
    uri - The uri to send the request to.
    
    Returns:
    
    The response of the request.
  - get
```
public static MockMvcResponse get(URL url)
```
    Perform a GET request to a url.
    
    Parameters:
    
    url - The url to send the request to.
    
    Returns:
    
    The response of the GET request.
  - post
```
public static MockMvcResponse post(URL url)
```
    Perform a POST request to a url.
    
    Parameters:
    
    url - The url to send the request to.
    
    Returns:
    
    The response of the request.
  - put
```
public static MockMvcResponse put(URL url)
```
    Perform a PUT request to a url.
    
    Parameters:
    
    url - The url to send the request to.
    
    Returns:
    
    The response of the request.
  - delete
```
public static MockMvcResponse delete(URL url)
```
    Perform a DELETE request to a url.
    
    Parameters:
    
    url - The url to send the request to.
    
    Returns:
    
    The response of the request.
  - head
```
public static MockMvcResponse head(URL url)
```
    Perform a HEAD request to a url.
    
    Parameters:
    
    url - The url to send the request to.
    
    Returns:
    
    The response of the request.
  - patch
```
public static MockMvcResponse patch(URL url)
```
    Perform a PATCH request to a url.
    
    Parameters:
    
    url - The url to send the request to.
    
    Returns:
    
    The response of the request.
  - options
```
public static MockMvcResponse options(URL url)
```
    Perform a OPTIONS request to a url.
    
    Parameters:
    
    url - The url to send the request to.
    
    Returns:
    
    The response of the request.
  - get
```
public static MockMvcResponse get()
```
    Perform a GET request to the statically configured base path.
    
    Returns:
    
    The response of the GET request.
  - post
```
public static MockMvcResponse post()
```
    Perform a POST request to the statically configured base path.
    
    Returns:
    
    The response of the request.
  - put
```
public static MockMvcResponse put()
```
    Perform a PUT request to the statically configured base path.
    
    Returns:
    
    The response of the request.
  - delete
```
public static MockMvcResponse delete()
```
    Perform a DELETE request to the statically configured base path.
    
    Returns:
    
    The response of the request.
  - head
```
public static MockMvcResponse head()
```
    Perform a HEAD request to the statically configured base path.
    
    Returns:
    
    The response of the request.
  - patch
```
public static MockMvcResponse patch()
```
    Perform a PATCH request to the statically configured base path.
    
    Returns:
    
    The response of the request.
  - options
```
public static MockMvcResponse options()
```
    Perform a OPTIONS request to the statically configured base path.
    
    Returns:
    
    The response of the request.
  - request
```
public static MockMvcResponse request(io.restassured.http.Method method)
```
    Perform a request to the pre-configured path (by default http://localhost:8080).
    
    Parameters:
    
    method - The HTTP method to use
    
    Returns:
    
    The response of the request.
  - request
```
public static MockMvcResponse request(String method)
```
    Perform a custom HTTP request to the pre-configured path (by default http://localhost:8080).
    
    Parameters:
    
    method - The HTTP method to use
    
    Returns:
    
    The response of the request.
  - request
```
public static MockMvcResponse request(io.restassured.http.Method method,
                                      String path,
                                      Object... pathParams)
```
    Perform a HTTP request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Parameters:
    
    method - The HTTP method to use
    
    path - The path to send the request to.
    
    pathParams - The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do request(Method.TRACE,"/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);.
    
    Returns:
    
    The response of the request.
  - request
```
public static MockMvcResponse request(String method,
                                      String path,
                                      Object... pathParams)
```
    Perform a custom HTTP request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Parameters:
    
    method - The HTTP method to use
    
    path - The path to send the request to.
    
    pathParams - The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do request("method","/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);.
    
    Returns:
    
    The response of the request.
  - request
```
public static MockMvcResponse request(io.restassured.http.Method method,
                                      URI uri)
```
    Perform a request to a uri.
    
    Parameters:
    
    method - The HTTP method to use
    
    uri - The uri to send the request to.
    
    Returns:
    
    The response of the GET request.
  - request
```
public static MockMvcResponse request(io.restassured.http.Method method,
                                      URL url)
```
    Perform a request to a url.
    
    Parameters:
    
    method - The HTTP method to use
    
    url - The url to send the request to.
    
    Returns:
    
    The response of the GET request.
  - request
```
public static MockMvcResponse request(String method,
                                      URI uri)
```
    Perform a custom HTTP request to a uri.
    
    Parameters:
    
    method - The HTTP method to use
    
    uri - The uri to send the request to.
    
    Returns:
    
    The response of the GET request.
  - request
```
public static MockMvcResponse request(String method,
                                      URL url)
```
    Perform a custom HTTP request to a url.
    
    Parameters:
    
    method - The HTTP method to use
    
    url - The url to send the request to.
    
    Returns:
    
    The response of the GET request.
  - principal
```
public static MockMvcAuthenticationScheme principal(Principal principal)
```
    Authenticate using the given principal. Used as:
```
 RestAssured.authentication = principal(myPrincipal);
 
```
    or in a MockMvcRequestSpecBuilder:
```
 MockMvcRequestSpecification req = new MockMvcRequestSpecBuilder().setAuth(principal(myPrincipal)). ..
 
```
    Parameters:
    
    principal - The principal to use.
    
    Returns:
    
    A MockMvcAuthenticationScheme instance.
    
    See Also:
    
    MockMvcAuthenticationSpecification.principal(java.security.Principal)
  - principal
```
public static MockMvcAuthenticationScheme principal(Object principal)
```
    Authenticate using the given principal. Used as:
```
 RestAssured.authentication = principal(myPrincipal);
 
```
    or in a MockMvcRequestSpecBuilder:
```
 MockMvcRequestSpecification req = new MockMvcRequestSpecBuilder().setAuth(principal(myPrincipal)). ..
 
```
    Parameters:
    
    principal - The principal to use.
    
    Returns:
    
    A MockMvcAuthenticationScheme instance.
    
    See Also:
    
    MockMvcAuthenticationSpecification.principal(Object)
  - principalWithCredentials
```
public static MockMvcAuthenticationScheme principalWithCredentials(Object principal,
                                                                   Object credentials,
                                                                   String... authorities)
```
    Authenticate using the given principal and credentials. Used as:
```
 RestAssured.authentication = principalWithCredentials(myPrincipal, myCredentials);
 
```
    or in a MockMvcRequestSpecBuilder:
```
 MockMvcRequestSpecification req = new MockMvcRequestSpecBuilder().setAuth(principalWithCredentials(myPrincipal, myCredentials)). ..
 
```
    Parameters:
    
    principal - The principal to use.
    
    credentials - The credentials to use
    
    authorities - Optional list of authorities
    
    Returns:
    
    A MockMvcAuthenticationScheme instance.
    
    See Also:
    
    MockMvcAuthenticationSpecification.principalWithCredentials(Object, Object, String...)
  - authentication
```
public static MockMvcAuthenticationScheme authentication(Object authentication)
```
    Authenticate using the supplied authentication instance (org.springframework.security.core.Authentication from Spring Security). Used as:
```
 RestAssured.authentication = authentication(myAuth);
 
```
    or in a MockMvcRequestSpecBuilder:
```
 MockMvcRequestSpecification req = new MockMvcRequestSpecBuilder().setAuth(authentication(myAuth)). ..
 
```
    Parameters:
    
    authentication - The authentication instance to use.
    
    Returns:
    
    A MockMvcAuthenticationScheme instance.
    
    See Also:
    
    MockMvcAuthenticationSpecification.authentication(Object)
  - with
```
public static MockMvcAuthenticationScheme with(org.springframework.test.web.servlet.request.RequestPostProcessor requestPostProcessor,
                                               org.springframework.test.web.servlet.request.RequestPostProcessor... additionalRequestPostProcessor)
```
    Authenticate using a RequestPostProcessor. This is mainly useful when you have added the spring-security-test artifact to classpath. This allows you to do for example:
```
 RestAssured.authentication = with(user("username").password("password"));
 
```
    where user is statically imported from org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.
    Parameters:
    
    requestPostProcessor - The first request post processor to be used for authentication
    
    additionalRequestPostProcessor - Additional request post processors to be used for authentication
    
    Returns:
    
    A MockMvcAuthenticationScheme instance.
  - enableLoggingOfRequestAndResponseIfValidationFails
```
public static void enableLoggingOfRequestAndResponseIfValidationFails()
```
    Enable logging of both the request and the response if REST Assureds test validation fails with log detail equal to LogDetail.ALL.
    
    This is just a shortcut for:
```
 RestAssuredMockMvc.config = new RestAssuredMockMvcConfig().logConfig(logConfig().enableLoggingOfRequestAndResponseIfValidationFails());
 
```
  - enableLoggingOfRequestAndResponseIfValidationFails
```
public static void enableLoggingOfRequestAndResponseIfValidationFails(io.restassured.filter.log.LogDetail logDetail)
```
    Enable logging of both the request and the response if REST Assureds test validation fails with the specified log detail.
    
    This is just a shortcut for:
```
 RestAssured.config = new RestAssuredMockMvcConfig().logConfig(logConfig().enableLoggingOfRequestAndResponseIfValidationFails(logDetail));
 
```
    Parameters:
    
    logDetail - The log detail to show in the log
  - config
```
public static RestAssuredMockMvcConfig config()
```
    Returns:
    
    The assigned config or a new config is no config is assigned

Class RestAssuredMockMvc

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

config

requestSpecification

responseSpecification

basePath

authentication

Constructor Detail

RestAssuredMockMvc

Method Detail

mockMvc

given

with

when

standaloneSetup

standaloneSetup

webAppContextSetup

resultHandlers

resultHandlers

postProcessors

postProcessors

reset

get

get

post

post

put

delete

delete

head

head

patch

patch

options

options

get

post

put

delete

head

patch

options

get

post

put

delete

head

patch

options

get

post

put

delete

head

patch

options

request

request

request

request

request

request

request

request

principal

principal

principalWithCredentials

authentication

with

enableLoggingOfRequestAndResponseIfValidationFails

enableLoggingOfRequestAndResponseIfValidationFails

config