WebTestClientRequestSpecification (spring-web-test-client 5.5.1 API)

All Superinterfaces:

io.restassured.specification.RequestSenderOptions<WebTestClientResponse>, WebTestClientRequestSender

All Known Implementing Classes:

WebTestClientRequestSpecificationImpl
```
public interface WebTestClientRequestSpecification
extends WebTestClientRequestSender
```

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`WebTestClientRequestSpecification`	`accept(io.restassured.http.ContentType contentType)` Specify the accept header of the request.
`WebTestClientRequestSpecification`	`accept(org.springframework.http.MediaType... mediaTypes)` Specify the accept header of the request.
`WebTestClientRequestSpecification`	`accept(String mediaTypes)` Specify the accept header of the request.
`WebTestClientRequestSpecification`	`and()` Syntactic sugar
`WebTestClientRequestSpecification`	`applicationContextSetup(org.springframework.context.ApplicationContext context, org.springframework.test.web.reactive.server.WebTestClientConfigurer... configurers)`
`WebTestClientRequestSpecification`	`attribute(String attributeName, Object attributeValue)` Specify a single-value request attribute
`WebTestClientRequestSpecification`	`attributes(Map<String,?> attributesMap)` Specify request attributes as a map
`WebTestClientRequestSpecification`	`body(byte[] body)` Specify a byte array request body that'll be sent with the request.
`WebTestClientRequestSpecification`	`body(File body)` Specify file content that'll be sent with the request.
`WebTestClientRequestSpecification`	`body(Object object)` Specify an Object request content that will automatically be serialized to JSON or XML and sent with the request.
`WebTestClientRequestSpecification`	`body(Object object, io.restassured.mapper.ObjectMapper mapper)` Specify an Object request content that will automatically be serialized to JSON or XML and sent with the request using a specific object mapper.
`WebTestClientRequestSpecification`	`body(Object object, io.restassured.mapper.ObjectMapperType mapperType)` Specify an Object request content that will automatically be serialized to JSON or XML and sent with the request using a specific object mapper type.
`WebTestClientRequestSpecification`	`body(String body)` Specify a String request body (such as e.g.
`WebTestClientRequestSpecification`	`config(RestAssuredWebTestClientConfig config)` Define a REST Assured WebTestClient configuration.
`WebTestClientRequestSpecification`	`config(SpecificationConfig config)`
`WebTestClientRequestSpecification`	`contentType(io.restassured.http.ContentType contentType)` Specify the content type of the request.
`WebTestClientRequestSpecification`	`contentType(org.springframework.http.MediaType mediaType)` Specify the content type of the request.
`WebTestClientRequestSpecification`	`contentType(String contentType)` Specify the content type of the request.
`WebTestClientRequestSpecification`	`cookie(io.restassured.http.Cookie cookie)` Specify a `Cookie` to send with the request.
`WebTestClientRequestSpecification`	`cookie(String cookieName, Object value, Object... additionalValues)` Specify a cookie that'll be sent with the request e.g:
`WebTestClientRequestSpecification`	`cookies(io.restassured.http.Cookies cookies)` Specify the cookies that'll be sent with the request as `Cookies`:
`WebTestClientRequestSpecification`	`cookies(Map<String,?> cookies)` Specify the cookies that'll be sent with the request as Map e.g:
`WebTestClientRequestSpecification`	`cookies(String firstCookieName, Object firstCookieValue, Object... cookieNameValuePairs)` Specify the cookies that'll be sent with the request.
`WebTestClientRequestSpecification`	`formParam(String parameterName, Collection<?> parameterValues)` Specify a multi-value form parameter that'll be sent with the request e.g:
`WebTestClientRequestSpecification`	`formParam(String parameterName, Object... parameterValues)` Specify a form parameter that'll be sent with the request.
`WebTestClientRequestSpecification`	`formParams(Map<String,?> parametersMap)` Specify the form parameters that'll be sent with the request.
`WebTestClientRequestSpecification`	`formParams(String firstParameterName, Object firstParameterValue, Object... parameterNameValuePairs)` Specify the form parameters that'll be sent with the request.
`WebTestClientRequestSpecification`	`header(io.restassured.http.Header header)` Specify a `Header` to send with the request.
`WebTestClientRequestSpecification`	`header(String headerName, Object headerValue, Object... additionalHeaderValues)` Specify a header that'll be sent with the request e.g:
`WebTestClientRequestSpecification`	`headers(io.restassured.http.Headers headers)` Specify the headers that'll be sent with the request as `Headers`, e.g:
`WebTestClientRequestSpecification`	`headers(Map<String,?> headers)` Specify the headers that'll be sent with the request as Map e.g:
`WebTestClientRequestSpecification`	`headers(String firstHeaderName, Object firstHeaderValue, Object... headerNameValuePairs)` Specify the headers that'll be sent with the request.
`WebTestClientRequestLogSpecification`	`log()` Returns the `WebTestClientRequestLogSpecification` that allows you to log different parts of the `WebTestClientRequestSpecification`.
`WebTestClientRequestSpecification`	`multiPart(File file)` Specify a file to upload to the server using multi-part form data uploading.
`WebTestClientRequestSpecification`	`multiPart(String controlName, File file)` Specify a file to upload to the server using multi-part form data uploading with a specific control name.
`WebTestClientRequestSpecification`	`multiPart(String controlName, File file, String mimeType)` Specify a file to upload to the server using multi-part form data uploading with a specific control name and mime-type.
`WebTestClientRequestSpecification`	`multiPart(String controlName, Object object)` Specify an object that will be serialized to JSON and uploaded to the server using multi-part form data uploading with a specific control name.
`WebTestClientRequestSpecification`	`multiPart(String controlName, Object object, String mimeType)` Specify an object that will be serialized and uploaded to the server using multi-part form data uploading with a specific control name.
`WebTestClientRequestSpecification`	`multiPart(String controlName, String contentBody)` Specify a string to send to the server using multi-part form data.
`WebTestClientRequestSpecification`	`multiPart(String controlName, String fileName, byte[] bytes)` Specify a byte-array to upload to the server using multi-part form data.
`WebTestClientRequestSpecification`	`multiPart(String controlName, String fileName, byte[] bytes, String mimeType)` Specify a byte-array to upload to the server using multi-part form data.
`WebTestClientRequestSpecification`	`multiPart(String controlName, String fileName, InputStream stream)` Specify an inputstream to upload to the server using multi-part form data.
`WebTestClientRequestSpecification`	`multiPart(String controlName, String fileName, InputStream stream, String mimeType)` Specify an inputstream to upload to the server using multi-part form data.
`WebTestClientRequestSpecification`	`multiPart(String controlName, String filename, Object object, String mimeType)` Specify an object that will be serialized and uploaded to the server using multi-part form data uploading with a specific control name.
`WebTestClientRequestSpecification`	`multiPart(String controlName, String contentBody, String mimeType)` Specify a string to send to the server using multi-part form data with a specific mime-type.
`WebTestClientRequestSpecification`	`param(String parameterName, Collection<?> parameterValues)` Specify a multi-value parameter that'll be sent with the request e.g:
`WebTestClientRequestSpecification`	`param(String parameterName, Object... parameterValues)` Specify a parameter that'll be sent with the request e.g:
`WebTestClientRequestSpecification`	`params(Map<String,?> parametersMap)` Specify the parameters that'll be sent with the request as Map e.g:
`WebTestClientRequestSpecification`	`params(String firstParameterName, Object firstParameterValue, Object... parameterNameValuePairs)` Specify the parameters that'll be sent with the request.
`WebTestClientRequestSpecification`	`pathParam(String parameterName, Object parameterValue)` Specify a path parameter.
`WebTestClientRequestSpecification`	`pathParams(Map<String,Object> parametersMap)` Specify the path parameters that'll be sent with the request.
`WebTestClientRequestSpecification`	`pathParams(String firstParameterName, Object firstParameterValue, Object... parameterNameValuePairs)` Specify the path parameters that'll be sent with the request.
`WebTestClientRequestSpecification`	`queryParam(String parameterName, Collection<?> parameterValues)` Specify a multi-value query parameter that'll be sent with the request e.g:
`WebTestClientRequestSpecification`	`queryParam(String parameterName, Object... parameterValues)` Specify a query parameter that'll be sent with the request.
`WebTestClientRequestSpecification`	`queryParams(Map<String,?> parametersMap)` Specify the query parameters that'll be sent with the request.
`WebTestClientRequestSpecification`	`queryParams(String firstParameterName, Object firstParameterValue, Object... parameterNameValuePairs)` Specify the query parameters that'll be sent with the request.
`WebTestClientRequestSpecification`	`sessionId(String sessionIdValue)` Set the session id for this request.
`WebTestClientRequestSpecification`	`sessionId(String sessionIdName, String sessionIdValue)` Set the session id name and value for this request.
`WebTestClientRequestSpecification`	`spec(WebTestClientRequestSpecification requestSpecificationToMerge)` Add request data from a pre-defined specification.
`WebTestClientRequestSpecification`	`standaloneSetup(Object... controllerOrWebTestClientConfigurer)` Build a `WebTestClient` by registering one or more `@Controller`'s instances and configuring Spring infrastructure programmatically.
`WebTestClientRequestSpecification`	`standaloneSetup(org.springframework.web.reactive.function.server.RouterFunction routerFunction, org.springframework.test.web.reactive.server.WebTestClientConfigurer... configurers)`
`WebTestClientRequestSpecification`	`standaloneSetup(org.springframework.test.web.reactive.server.WebTestClient.Builder builder)` Build a `WebTestClient` by using a provided `AbstractWebTestClientBuilder` for configuring Spring infrastructure programmatically.
`WebTestClientRequestSpecification`	`webAppContextSetup(org.springframework.web.context.WebApplicationContext context, org.springframework.test.web.reactive.server.WebTestClientConfigurer... configurers)` Build a `WebTestClient` using the given, fully initialized, i.e.
`WebTestClientRequestSpecification`	`webTestClient(org.springframework.test.web.reactive.server.WebTestClient webTestClient)` Provide a `WebTestClient` instance to that REST Assured will use when making this request.
`WebTestClientRequestSender`	`when()` Call this method when you're done setting up the request specification.

Methods inherited from interface io.restassured.module.webtestclient.specification.WebTestClientRequestSender
consumeWith, delete, get, head, options, patch, post, put, request, request

Methods inherited from interface io.restassured.specification.RequestSenderOptions
delete, delete, delete, delete, delete, get, get, get, get, get, head, head, head, head, head, options, options, options, options, options, patch, patch, patch, patch, patch, post, post, post, post, post, put, put, put, put, put, request, request, request, request, request, request, request, request

- Method Detail
  - contentType
```
WebTestClientRequestSpecification contentType(io.restassured.http.ContentType contentType)
```
    Specify the content type of the request.
    
    Parameters:
    
    contentType - The content type of the request
    
    Returns:
    
    The request specification
    
    See Also:
    
    ContentType
  - contentType
```
WebTestClientRequestSpecification contentType(org.springframework.http.MediaType mediaType)
```
    Specify the content type of the request.
    
    Parameters:
    
    mediaType - The content type of the request
    
    Returns:
    
    The request specification
    
    See Also:
    
    ContentType
  - contentType
```
WebTestClientRequestSpecification contentType(String contentType)
```
    Specify the content type of the request.
    
    Parameters:
    
    contentType - The content type of the request
    
    Returns:
    
    The request specification
    
    See Also:
    
    ContentType
  - accept
```
WebTestClientRequestSpecification accept(io.restassured.http.ContentType contentType)
```
    Specify the accept header of the request. This just a shortcut for:
```
 header("Accept", contentType);
 
```
    Parameters:
    
    contentType - The content type whose accept header ContentType.getAcceptHeader() will be used as Accept header in the request.
    
    Returns:
    
    The request specification
    
    See Also:
    
    ContentType, header(String, Object, Object...)
  - accept
```
WebTestClientRequestSpecification accept(org.springframework.http.MediaType... mediaTypes)
```
    Specify the accept header of the request. This just a shortcut for:
```
 header("Accept", contentType);
 
```
    Parameters:
    
    mediaTypes - The media type(s) that will be used as Accept header in the request.
    
    Returns:
    
    The request specification
    
    See Also:
    
    ContentType, header(String, Object, Object...)
  - accept
```
WebTestClientRequestSpecification accept(String mediaTypes)
```
    Specify the accept header of the request. This just a shortcut for:
```
 header("Accept", contentType);
 
```
    Parameters:
    
    mediaTypes - The media type(s) that will be used as Accept header in the request.
    
    Returns:
    
    The request specification
    
    See Also:
    
    ContentType, header(String, Object, Object...)
  - headers
```
WebTestClientRequestSpecification headers(String firstHeaderName,
                                          Object firstHeaderValue,
                                          Object... headerNameValuePairs)
```
    Specify the headers that'll be sent with the request. This is done by specifying the headers in name-value pairs, e.g:
```
 given().headers("headerName1", "headerValue1", "headerName2", "headerValue2").then().expect().body(equalTo("something")).when().get("/headers");
 
```
    This will send a GET request to "/headers" with two headers:
    1. headerName1=headerValue1
    2. headerName2=headerValue2
    and expect that the response body is equal to "something".
    Parameters:
    
    firstHeaderName - The name of the first header
    
    firstHeaderValue - The value of the first header
    
    headerNameValuePairs - Additional headers in name-value pairs.
    
    Returns:
    
    The request specification
  - headers
```
WebTestClientRequestSpecification headers(Map<String,?> headers)
```
    Specify the headers that'll be sent with the request as Map e.g:
```
 Map<String, String> headers = new HashMap<String, String>();
 parameters.put("headerName1", "headerValue1");
 parameters.put("headerName2", "headerValue2");
 given().headers(headers).then().expect().body(equalTo("something")).when().get("/headers");
 
```
    This will send a GET request to "/headers" with two headers:
    1. headerName1=headerValue1
    2. headerName2=headerValue2
    and expect that the response body is equal to "something".
    Parameters:
    
    headers - The Map containing the header names and their values to send with the request.
    
    Returns:
    
    The request specification
  - headers
```
WebTestClientRequestSpecification headers(io.restassured.http.Headers headers)
```
    Specify the headers that'll be sent with the request as Headers, e.g:
```
 Header first = new Header("headerName1", "headerValue1");
 Header second = new Header("headerName2", "headerValue2");
 Headers headers = new Header(first, second);
 given().headers(headers).then().expect().body(equalTo("something")).when().get("/headers");
 
```
    This will send a GET request to "/headers" with two headers:
    1. headerName1=headerValue1
    2. headerName2=headerValue2
    and expect that the response body is equal to "something".
    Parameters:
    
    headers - The headers to use in the request
    
    Returns:
    
    The request specification
  - header
```
WebTestClientRequestSpecification header(String headerName,
                                         Object headerValue,
                                         Object... additionalHeaderValues)
```
    Specify a header that'll be sent with the request e.g:
```
 given().header("username", "John").and().expect().body(equalTo("something")).when().get("/header");
 
```
    This will set the header username=John in the GET request to "/header".
    
    You can also specify several headers like this:
```
 given().header("username", "John").and().header("zipCode", "12345").and().expect().body(equalTo("something")).when().get("/header");
 
```
    If you specify additionalHeaderValues then the Header will be a multi-value header. This means that you'll create several headers with the same name but with different values.
    Parameters:
    
    headerName - The header name
    
    headerValue - The header value
    
    additionalHeaderValues - Additional header values. This will actually create two headers with the same name but with different values.
    
    Returns:
    
    The request specification
    
    See Also:
    
    headers(String, Object, Object...)
  - header
```
WebTestClientRequestSpecification header(io.restassured.http.Header header)
```
    Specify a Header to send with the request.
```
 Header someHeader = new Header("some_name", "some_value");
 given().header(someHeader).and().expect().body(equalTo("x")).when().get("/header");
 
```
    This will set the header some_name=some_value in the GET request to "/header".
    Parameters:
    
    header - The header to add to the request
    
    Returns:
    
    The request specification
    
    See Also:
    
    headers(Headers)
  - log
```
WebTestClientRequestLogSpecification log()
```
    Returns the WebTestClientRequestLogSpecification that allows you to log different parts of the WebTestClientRequestSpecification. This is mainly useful for debug purposes when writing your tests.
    
    Returns:
    
    the request log specification
  - params
```
WebTestClientRequestSpecification params(String firstParameterName,
                                         Object firstParameterValue,
                                         Object... parameterNameValuePairs)
```
    Specify the parameters that'll be sent with the request. This is done by specifying the parameters in name-value pairs, e.g:
```
 given().params("username", "John", "token", "1234").when().get("/parameters").then().assertThat().body(equalTo("username, token"));
 
```
    This will send a GET request to "/parameters" with two parameters:
    1. username=John
    2. token=1234
    and expect that the response body is equal to "username, token".
    Parameters:
    
    firstParameterName - The name of the first parameter
    
    firstParameterValue - The value of the first parameter
    
    parameterNameValuePairs - Additional parameters in name-value pairs.
    
    Returns:
    
    The request specification
  - params
```
WebTestClientRequestSpecification params(Map<String,?> parametersMap)
```
    Specify the parameters that'll be sent with the request as Map e.g:
```
 Map<String, String> parameters = new HashMap<String, String>();
 parameters.put("username", "John");
 parameters.put("token", "1234");
 given().params(parameters).when().get("/cookie").then().assertThat().body(equalTo("username, token")).;
 
```
    This will send a GET request to "/cookie" with two parameters:
    1. username=John
    2. token=1234
    and expect that the response body is equal to "username, token".
    Parameters:
    
    parametersMap - The Map containing the parameter names and their values to send with the request.
    
    Returns:
    
    The request specification
  - param
```
WebTestClientRequestSpecification param(String parameterName,
                                        Object... parameterValues)
```
    Specify a parameter that'll be sent with the request e.g:
```
 given().parameter("username", "John").and().expect().body(equalTo("username")).when().get("/cookie");
 
```
    This will set the parameter username=John in the GET request to "/cookie".
    
    You can also specify several parameters like this:
```
 given().param("username", "John").and().param("password", "1234").when().get("/cookie").then().assertThat().body(equalTo("username")).;
 
```
    Parameters:
    
    parameterName - The parameter name
    
    parameterValues - Zero to many parameter values for this parameter name
    
    Returns:
    
    The request specification
    
    See Also:
    
    params(String, Object, Object...)
  - param
```
WebTestClientRequestSpecification param(String parameterName,
                                        Collection<?> parameterValues)
```
    Specify a multi-value parameter that'll be sent with the request e.g:
```
 given().param("cars", asList("Volvo", "Saab"))..;
 
```
    This will set the parameter cars=Volvo and cars=Saab.
    Parameters:
    
    parameterName - The parameter name
    
    parameterValues - The parameter values
    
    Returns:
    
    The request specification
  - queryParams
```
WebTestClientRequestSpecification queryParams(String firstParameterName,
                                              Object firstParameterValue,
                                              Object... parameterNameValuePairs)
```
    Specify the query parameters that'll be sent with the request. Note that this method is the same as params(String, Object, Object...) for all http methods except for POST where params(String, Object, Object...) sets the form parameters and this method sets the query parameters.
    
    Parameters:
    
    firstParameterName - The name of the first parameter
    
    firstParameterValue - The value of the first parameter
    
    parameterNameValuePairs - The value of the first parameter followed by additional parameters in name-value pairs.
    
    Returns:
    
    The request specification
  - queryParams
```
WebTestClientRequestSpecification queryParams(Map<String,?> parametersMap)
```
    Specify the query parameters that'll be sent with the request. Note that this method is the same as params(Map) for all http methods except for POST where params(Map) sets the form parameters and this method sets the query parameters.
    
    Parameters:
    
    parametersMap - The Map containing the parameter names and their values to send with the request.
    
    Returns:
    
    The request specification
  - queryParam
```
WebTestClientRequestSpecification queryParam(String parameterName,
                                             Object... parameterValues)
```
    Specify a query parameter that'll be sent with the request. Note that this method is the same as param(String, Object...) for all http methods except for POST where param(String, Object...) adds a form parameter and this method sets a query parameter.
    
    Parameters:
    
    parameterName - The parameter name
    
    parameterValues - Zero to many parameter values, i.e. you can specify multiple values for the same parameter
    
    Returns:
    
    The request specification
    
    See Also:
    
    param(String, Object...)
  - queryParam
```
WebTestClientRequestSpecification queryParam(String parameterName,
                                             Collection<?> parameterValues)
```
    Specify a multi-value query parameter that'll be sent with the request e.g:
```
 given().queryParam("cars", asList("Volvo", "Saab"))..;
 
```
    This will set the parameter cars=Volvo and cars=Saab.
    
    Note that this method is the same as param(String, java.util.Collection) for all http methods except for POST where param(String, java.util.Collection) adds a form parameter and this method sets a query parameter.
    Parameters:
    
    parameterName - The parameter name
    
    parameterValues - The parameter values
    
    Returns:
    
    The request specification
  - pathParams
```
WebTestClientRequestSpecification pathParams(String firstParameterName,
                                             Object firstParameterValue,
                                             Object... parameterNameValuePairs)
```
    Specify the path parameters that'll be sent with the request.
    
    Parameters:
    
    firstParameterName - The name of the first parameter
    
    firstParameterValue - The value of the first parameter
    
    parameterNameValuePairs - The value of the first parameter followed by additional parameters in name-value pairs.
    
    Returns:
    
    The request specification
  - pathParams
```
WebTestClientRequestSpecification pathParams(Map<String,Object> parametersMap)
```
    Specify the path parameters that'll be sent with the request.
    
    Parameters:
    
    parametersMap - The Map containing the parameter names and their values to send with the request.
    
    Returns:
    
    The request specification
  - pathParam
```
WebTestClientRequestSpecification pathParam(String parameterName,
                                            Object parameterValue)
```
    Specify a path parameter. Path parameters are used to improve readability of the request path. E.g. instead of writing:
```
 when().
        get("/item/"+myItem.getItemNumber()+"/buy/"+2).
 then().
        statusCode(200);
 
```
    you can write:
```
 given().
         pathParam("itemNumber", myItem.getItemNumber()).
         pathParam("amount", 2).
 when().
        get("/item/{itemNumber}/buy/{amount}").
 then().
          statusCode(200);
 
```
    which improves readability and allows the path to be reusable in many tests. Another alternative is to use:
```
 when().get("/item/{itemNumber}/buy/{amount}", myItem.getItemNumber(), 2).then().statusCode(200).;
 
```
    Parameters:
    
    parameterName - The parameter name
    
    parameterValue - The parameter value
    
    Returns:
    
    The request specification
  - formParams
```
WebTestClientRequestSpecification formParams(String firstParameterName,
                                             Object firstParameterValue,
                                             Object... parameterNameValuePairs)
```
    Specify the form parameters that'll be sent with the request. Note that this method is the same as params(String, Object, Object...) for all http methods except for POST where params(String, Object, Object...) sets the form parameters and this method sets the form parameters.
    
    Parameters:
    
    firstParameterName - The name of the first parameter
    
    firstParameterValue - The value of the first parameter
    
    parameterNameValuePairs - The value of the first parameter followed by additional parameters in name-value pairs.
    
    Returns:
    
    The request specification
  - formParams
```
WebTestClientRequestSpecification formParams(Map<String,?> parametersMap)
```
    Specify the form parameters that'll be sent with the request. Note that this method is the same as params(Map) for all http methods except for POST where params(Map) sets the form parameters and this method sets the form parameters.
    
    Parameters:
    
    parametersMap - The Map containing the parameter names and their values to send with the request.
    
    Returns:
    
    The request specification
  - formParam
```
WebTestClientRequestSpecification formParam(String parameterName,
                                            Object... parameterValues)
```
    Specify a form parameter that'll be sent with the request. Note that this method is the same as param(String, Object...) for all http methods except for POST where param(String, Object...) adds a form parameter and this method sets a form parameter.
    
    Parameters:
    
    parameterName - The parameter name
    
    parameterValues - Zero to many parameter values, i.e. you can specify multiple values for the same parameter
    
    Returns:
    
    The request specification
    
    See Also:
    
    param(String, Object...)
  - formParam
```
WebTestClientRequestSpecification formParam(String parameterName,
                                            Collection<?> parameterValues)
```
    Specify a multi-value form parameter that'll be sent with the request e.g:
```
 given().formParam("cars", asList("Volvo", "Saab"))..;
 
```
    This will set the parameter cars=Volvo and cars=Saab.
    
    Note that this method is the same as param(String, java.util.Collection) for all http methods except for POST where param(String, java.util.Collection) adds a form parameter and this method sets a form parameter.
    Parameters:
    
    parameterName - The parameter name
    
    parameterValues - The parameter values
    
    Returns:
    
    The request specification
  - attribute
```
WebTestClientRequestSpecification attribute(String attributeName,
                                            Object attributeValue)
```
    Specify a single-value request attribute
    
    Parameters:
    
    attributeName - The attribute name
    
    attributeValue - The attribute value
    
    Returns:
    
    The request specification
  - attributes
```
WebTestClientRequestSpecification attributes(Map<String,?> attributesMap)
```
    Specify request attributes as a map
    
    Parameters:
    
    attributesMap - The Map containing the request attribute names and their values
    
    Returns:
    
    The request specification
  - body
```
WebTestClientRequestSpecification body(String body)
```
    Specify a String request body (such as e.g. JSON or XML) that'll be sent with the request. This works for the POST and PUT methods only. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 given().body("{ \"message\" : \"hello world\"}").then().expect().body(equalTo("hello world")).when().post("/json");
 
```
    This will POST a request containing JSON to "/json" and expect that the response body equals to "hello world".
    Parameters:
    
    body - The body to send.
    
    Returns:
    
    The request specification
  - body
```
WebTestClientRequestSpecification body(byte[] body)
```
    Specify a byte array request body that'll be sent with the request. This only works for the POST http method. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 byte[] someBytes = ..
 given().body(someBytes).then().expect().body(equalTo("hello world")).when().post("/json");
 
```
    This will POST a request containing someBytes to "/json" and expect that the response body equals to "hello world".
    Parameters:
    
    body - The body to send.
    
    Returns:
    
    The request specification
  - body
```
WebTestClientRequestSpecification body(File body)
```
    Specify file content that'll be sent with the request. This only works for the POST, PATCH and PUT http method. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 File myFile = ..
 given().content(myFile).when().post("/json").then().content(equalTo("hello world"));
 
```
    This will POST a request containing myFile to "/json" and expect that the response content equals to "hello world".
    Parameters:
    
    body - The content to send.
    
    Returns:
    
    The request specification
  - body
```
WebTestClientRequestSpecification body(Object object)
```
    Specify an Object request content that will automatically be serialized to JSON or XML and sent with the request. If the object is a primitive or Number the object will be converted to a String and put in the request body. This works for the POST and PUT methods only. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 Message message = new Message();
 message.setMessage("My beautiful message");

 given().
         contentType("application/json").
         body(message).
 expect().
         content(equalTo("Response to a beautiful message")).
 when().
         post("/beautiful-message");
 
```
    Since the content-type is "application/json" then REST Assured will automatically try to serialize the object using Jackson or Gson if they are available in the classpath. If any of these frameworks are not in the classpath then an exception is thrown.
    If the content-type is "application/xml" then REST Assured will automatically try to serialize the object using JAXB if it's available in the classpath. Otherwise an exception will be thrown.
    If no request content-type is specified then REST Assured determine the parser in the following order:
    1. Jackson
    2. Gson
    3. JAXB
    Parameters:
    
    object - The object to serialize and send with the request
    
    Returns:
    
    The request specification
  - body
```
WebTestClientRequestSpecification body(Object object,
                                       io.restassured.mapper.ObjectMapper mapper)
```
    Specify an Object request content that will automatically be serialized to JSON or XML and sent with the request using a specific object mapper. This works for the POST, PATCH and PUT methods only. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 Message message = new Message();
 message.setMessage("My beautiful message");

 given().
         body(message, new MyObjectMapper()).
 expect().
         content(equalTo("Response to a beautiful message")).
 when().
         post("/beautiful-message");
 
```
    Parameters:
    
    object - The object to serialize and send with the request
    
    mapper - The object mapper
    
    Returns:
    
    The request specification
  - body
```
WebTestClientRequestSpecification body(Object object,
                                       io.restassured.mapper.ObjectMapperType mapperType)
```
    Specify an Object request content that will automatically be serialized to JSON or XML and sent with the request using a specific object mapper type. This works for the POST, PATCH and PUT methods only. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 Message message = new Message();
 message.setMessage("My beautiful message");

 given().
         body(message, ObjectMapper.GSON).
 expect().
         content(equalTo("Response to a beautiful message")).
 when().
         post("/beautiful-message");
 
```
    Parameters:
    
    object - The object to serialize and send with the request
    
    mapperType - The object mapper type to be used
    
    Returns:
    
    The request specification
  - cookies
```
WebTestClientRequestSpecification cookies(String firstCookieName,
                                          Object firstCookieValue,
                                          Object... cookieNameValuePairs)
```
    Specify the cookies that'll be sent with the request. This is done by specifying the cookies in name-value pairs, e.g:
```
 given().cookies("username", "John", "token", "1234").then().expect().body(equalTo("username, token")).when().get("/cookie");
 
```
    This will send a GET request to "/cookie" with two cookies:
    1. username=John
    2. token=1234
    and expect that the response body is equal to "username, token".
    Parameters:
    
    firstCookieName - The name of the first cookie
    
    firstCookieValue - The value of the first cookie
    
    cookieNameValuePairs - Additional cookies in name-value pairs.
    
    Returns:
    
    The request specification
  - cookies
```
WebTestClientRequestSpecification cookies(Map<String,?> cookies)
```
    Specify the cookies that'll be sent with the request as Map e.g:
```
 Map<String, String> cookies = new HashMap<String, String>();
 cookies.put("username", "John");
 cookies.put("token", "1234");
 given().cookies(cookies).then().expect().body(equalTo("username, token")).when().get("/cookie");
 
```
    This will send a GET request to "/cookie" with two cookies:
    1. username=John
    2. token=1234
    and expect that the response body is equal to "username, token".
    Parameters:
    
    cookies - The Map containing the cookie names and their values to set in the request.
    
    Returns:
    
    The request specification
  - cookies
```
WebTestClientRequestSpecification cookies(io.restassured.http.Cookies cookies)
```
    Specify the cookies that'll be sent with the request as Cookies:
```
 Cookie cookie1 = Cookie.Builder("username", "John").setComment("comment 1").build();
 Cookie cookie2 = Cookie.Builder("token", 1234).setComment("comment 2").build();
 Cookies cookies = new Cookies(cookie1, cookie2);
 given().cookies(cookies).then().expect().body(equalTo("username, token")).when().get("/cookie");
 
```
    This will send a GET request to "/cookie" with two cookies:
    1. username=John
    2. token=1234
    and expect that the response body is equal to "username, token".
    Parameters:
    
    cookies - The cookies to set in the request.
    
    Returns:
    
    The request specification
  - cookie
```
WebTestClientRequestSpecification cookie(String cookieName,
                                         Object value,
                                         Object... additionalValues)
```
    Specify a cookie that'll be sent with the request e.g:
```
 given().cookie("username", "John").and().expect().body(equalTo("username")).when().get("/cookie");
 
```
    This will set the cookie username=John in the GET request to "/cookie".
    
    You can also specify several cookies like this:
```
 given().cookie("username", "John").and().cookie("password", "1234").and().expect().body(equalTo("username")).when().get("/cookie");
 
```
    If you specify additionalValues then the Cookie will be a multi-value cookie. This means that you'll create several cookies with the same name but with different values.
    Parameters:
    
    cookieName - The cookie cookieName
    
    value - The cookie value
    
    additionalValues - Additional cookies values. This will actually create two cookies with the same name but with different values.
    
    Returns:
    
    The request specification
    
    See Also:
    
    cookies(String, Object, Object...)
  - cookie
```
WebTestClientRequestSpecification cookie(io.restassured.http.Cookie cookie)
```
    Specify a Cookie to send with the request.
```
 Cookie someCookie = new Cookie.Builder("some_cookie", "some_value").setSecured(true).build();
 given().cookie(someCookie).and().expect().body(equalTo("x")).when().get("/cookie");
 
```
    This will set the cookie someCookie in the GET request to "/cookie".
    Parameters:
    
    cookie - The cookie to add to the request
    
    Returns:
    
    The request specification
    
    See Also:
    
    cookies(Cookies)
  - multiPart
```
WebTestClientRequestSpecification multiPart(File file)
```
    Specify a file to upload to the server using multi-part form data uploading. It will assume that the control name is file and the mime-type is application/octet-stream. If this is not what you want please use an overloaded method.
    
    Parameters:
    
    file - The file to upload
    
    Returns:
    
    The request specification
  - multiPart
```
WebTestClientRequestSpecification multiPart(String controlName,
                                            File file)
```
    Specify a file to upload to the server using multi-part form data uploading with a specific control name. It will use the mime-type application/octet-stream. If this is not what you want please use an overloaded method.
    
    Parameters:
    
    file - The file to upload
    
    controlName - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    Returns:
    
    The request specification
  - multiPart
```
WebTestClientRequestSpecification multiPart(String controlName,
                                            File file,
                                            String mimeType)
```
    Specify a file to upload to the server using multi-part form data uploading with a specific control name and mime-type.
    
    Parameters:
    
    file - The file to upload
    
    controlName - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    mimeType - The mime-type
    
    Returns:
    
    The request specification
  - multiPart
```
WebTestClientRequestSpecification multiPart(String controlName,
                                            Object object)
```
    Specify an object that will be serialized to JSON and uploaded to the server using multi-part form data uploading with a specific control name. It will use mime-type application/json. If this is not what you want please use an overloaded method.
    
    Parameters:
    
    controlName - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    object - The object to serialize to JSON or XML and send to the server
    
    Returns:
    
    The request specification
  - multiPart
```
WebTestClientRequestSpecification multiPart(String controlName,
                                            Object object,
                                            String mimeType)
```
    Specify an object that will be serialized and uploaded to the server using multi-part form data uploading with a specific control name.
    
    Parameters:
    
    controlName - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    object - The object to serialize to JSON or XML and send to the server
    
    mimeType - The mime-type
    
    Returns:
    
    The request specification
  - multiPart
```
WebTestClientRequestSpecification multiPart(String controlName,
                                            String filename,
                                            Object object,
                                            String mimeType)
```
    Specify an object that will be serialized and uploaded to the server using multi-part form data uploading with a specific control name.
    
    Parameters:
    
    controlName - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    filename - The name of the content you're uploading
    
    object - The object to serialize to JSON or XML and send to the server
    
    mimeType - The mime-type
    
    Returns:
    
    The request specification
  - multiPart
```
WebTestClientRequestSpecification multiPart(String controlName,
                                            String fileName,
                                            byte[] bytes)
```
    Specify a byte-array to upload to the server using multi-part form data. It will use the mime-type application/octet-stream. If this is not what you want please use an overloaded method.
    
    Parameters:
    
    controlName - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    fileName - The name of the content you're uploading
    
    bytes - The bytes you want to send
    
    Returns:
    
    The request specification
  - multiPart
```
WebTestClientRequestSpecification multiPart(String controlName,
                                            String fileName,
                                            byte[] bytes,
                                            String mimeType)
```
    Specify a byte-array to upload to the server using multi-part form data.
    
    Parameters:
    
    controlName - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    fileName - The name of the content you're uploading
    
    bytes - The bytes you want to send
    
    mimeType - The mime-type
    
    Returns:
    
    The request specification
  - multiPart
```
WebTestClientRequestSpecification multiPart(String controlName,
                                            String fileName,
                                            InputStream stream)
```
    Specify an inputstream to upload to the server using multi-part form data. It will use the mime-type application/octet-stream. If this is not what you want please use an overloaded method.
    
    Parameters:
    
    controlName - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    fileName - The name of the content you're uploading
    
    stream - The stream you want to send
    
    Returns:
    
    The request specification
  - multiPart
```
WebTestClientRequestSpecification multiPart(String controlName,
                                            String fileName,
                                            InputStream stream,
                                            String mimeType)
```
    Specify an inputstream to upload to the server using multi-part form data.
    
    Parameters:
    
    controlName - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    fileName - The name of the content you're uploading
    
    stream - The stream you want to send
    
    mimeType - The mime-type
    
    Returns:
    
    The request specification
  - multiPart
```
WebTestClientRequestSpecification multiPart(String controlName,
                                            String contentBody)
```
    Specify a string to send to the server using multi-part form data. It will use the mime-type text/plain. If this is not what you want please use an overloaded method.
    
    Parameters:
    
    controlName - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    contentBody - The string to send
    
    Returns:
    
    The request specification
  - multiPart
```
WebTestClientRequestSpecification multiPart(String controlName,
                                            String contentBody,
                                            String mimeType)
```
    Specify a string to send to the server using multi-part form data with a specific mime-type.
    
    Parameters:
    
    controlName - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    contentBody - The string to send
    
    mimeType - The mime-type
    
    Returns:
    
    The request specification
  - config
```
WebTestClientRequestSpecification config(RestAssuredWebTestClientConfig config)
```
    Define a REST Assured WebTestClient configuration. E.g.
```
 given().config(newConfig().logConfig(new LogConfig(captor, true))). ..
 
```
    newConfig() can be statically imported from RestAssuredWebTestClientConfig.
    Parameters:
    
    config - The configuration to use for this request. If null no config will be used.
    
    Returns:
    
    The request specification
  - config
```
WebTestClientRequestSpecification config(SpecificationConfig config)
```
  - spec
```
WebTestClientRequestSpecification spec(WebTestClientRequestSpecification requestSpecificationToMerge)
```
    Add request data from a pre-defined specification. E.g.
```
 WebTestClientRequestSpecification requestSpec = new WebTestClientRequestSpecBuilder().addParam("parameter1", "value1").build();

 given().
         spec(requestSpec).
         param("parameter2", "value2").
 when().
        get("/something");
 
```
    This is useful when you want to reuse an entire specification across multiple requests.
    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
    - Request body
    - Interceptions
    - Log (if defined in requestSpecificationToMerge)
    - Config
    The following settings are merged:
    - Parameters
    - Attributes
    - Cookies
    - Headers
    Parameters:
    
    requestSpecificationToMerge - The specification to merge with.
    
    Returns:
    
    the request specification
  - sessionId
```
WebTestClientRequestSpecification sessionId(String sessionIdValue)
```
    Set the session id for this request. It will use the configured session id name from the configuration (by default this is ). You can configure the session id name by using:
```
     RestAssured.config = newConfig().sessionConfig(new SessionConfig().sessionIdName(<sessionIdName>));
 
```
    or you can use the sessionId(String, String) method to set it for this request only.
    Parameters:
    
    sessionIdValue - The session id value.
    
    Returns:
    
    The request specification
  - sessionId
```
WebTestClientRequestSpecification sessionId(String sessionIdName,
                                            String sessionIdValue)
```
    Set the session id name and value for this request. It'll override the default session id name from the configuration (by default this is ). You can configure the default session id name by using:
```
     RestAssured.config = newConfig().sessionConfig(new SessionConfig().sessionIdName(<sessionIdName>));
 
```
    and then you can use the sessionId(String) method to set the session id value without specifying the name for each request.
    Parameters:
    
    sessionIdName - The session id name
    
    sessionIdValue - The session id value.
    
    Returns:
    
    The request specification
  - when
```
WebTestClientRequestSender when()
```
    Call this method when you're done setting up the request specification.
    
    Returns:
    
    The WebTestClientRequestSender that let's you send the request.
  - standaloneSetup
```
WebTestClientRequestSpecification standaloneSetup(Object... controllerOrWebTestClientConfigurer)
```
    Build a WebTestClient by registering one or more @Controller's instances and configuring Spring infrastructure programmatically. This allows full control over the instantiation and initialization of controllerOrWebTestClientConfigurer, and their dependencies, similar to plain unit tests while also making it possible to test one controller at a time.
    
    This uses the WebTestClient.bindToController(Object...) method under the hood.
    
    Parameters:
    
    controllerOrWebTestClientConfigurer - one or more @Controller's to test or a combination of controllers and WebTestClientConfigurer
  - standaloneSetup
```
WebTestClientRequestSpecification standaloneSetup(org.springframework.test.web.reactive.server.WebTestClient.Builder builder)
```
    Build a WebTestClient by using a provided AbstractWebTestClientBuilder for configuring Spring 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.
    
    This uses the WebTestClient.Builder to set up the WebTestClient instance.
    
    Parameters:
    
    builder - WebTestClient.Builder to build the WebTestClient instance.
  - standaloneSetup
```
WebTestClientRequestSpecification standaloneSetup(org.springframework.web.reactive.function.server.RouterFunction routerFunction,
                                                  org.springframework.test.web.reactive.server.WebTestClientConfigurer... configurers)
```
  - webTestClient
```
WebTestClientRequestSpecification webTestClient(org.springframework.test.web.reactive.server.WebTestClient webTestClient)
```
    Provide a WebTestClient instance to that REST Assured will use when making this request.
    
    Parameters:
    
    webTestClient - WebTestClient instance to use.
    
    Returns:
    
    The request specification
  - webAppContextSetup
```
WebTestClientRequestSpecification webAppContextSetup(org.springframework.web.context.WebApplicationContext context,
                                                     org.springframework.test.web.reactive.server.WebTestClientConfigurer... configurers)
```
    Build a WebTestClient using the given, fully initialized, i.e. refreshed, WebApplicationContext and assign it to REST Assured. This method has been kept for consistency, but, actually, it is only be used as ApplicationContext. The effect of calling this method is same as for applicationContextSetup(ApplicationContext, WebTestClientConfigurer...)
    
    Parameters:
    
    context - The web application context to use
    
    configurers - WebTestClientConfigurer's to be applied when creating a WebTestClient instance of this WebApplicationContext (optional)
  - applicationContextSetup
```
WebTestClientRequestSpecification applicationContextSetup(org.springframework.context.ApplicationContext context,
                                                          org.springframework.test.web.reactive.server.WebTestClientConfigurer... configurers)
```
  - and
```
WebTestClientRequestSpecification and()
```
    Syntactic sugar
    
    Returns:
    
    The same WebTestClientRequestSpecification instance.

Interface WebTestClientRequestSpecification

Method Summary

Methods inherited from interface io.restassured.module.webtestclient.specification.WebTestClientRequestSender

Methods inherited from interface io.restassured.specification.RequestSenderOptions

Method Detail

contentType

contentType

contentType

accept

accept

accept

headers

headers

headers

header

header

log

params

params

param

param

queryParams

queryParams

queryParam

queryParam

pathParams

pathParams

pathParam

formParams

formParams

formParam

formParam

attribute

attributes

body

body

body

body

body

body

cookies

cookies

cookies

cookie

cookie

multiPart

multiPart

multiPart

multiPart

multiPart

multiPart

multiPart

multiPart

multiPart

multiPart

multiPart

multiPart

config

config

spec

sessionId

sessionId

when

standaloneSetup

standaloneSetup

standaloneSetup

webTestClient

webAppContextSetup

applicationContextSetup

and