/*
* Copyright 2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.restassured.module.mockmvc;
import io.restassured.RestAssured;
import io.restassured.config.LogConfig;
import io.restassured.filter.log.LogDetail;
import io.restassured.http.Method;
import io.restassured.module.mockmvc.config.RestAssuredMockMvcConfig;
import io.restassured.module.mockmvc.internal.MockMvcFactory;
import io.restassured.module.mockmvc.internal.MockMvcRequestSpecificationImpl;
import io.restassured.module.mockmvc.internal.StandaloneMockMvcFactory;
import io.restassured.module.mockmvc.response.MockMvcResponse;
import io.restassured.module.mockmvc.specification.*;
import io.restassured.specification.ResponseSpecification;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MockMvcBuilder;
import org.springframework.test.web.servlet.ResultHandler;
import org.springframework.test.web.servlet.request.RequestPostProcessor;
import org.springframework.test.web.servlet.setup.DefaultMockMvcBuilder;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.test.web.servlet.setup.MockMvcConfigurer;
import org.springframework.web.context.WebApplicationContext;
import java.net.URI;
import java.net.URL;
import java.security.Principal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import static io.restassured.config.LogConfig.logConfig;
import static io.restassured.internal.assertion.AssertParameter.notNull;
/**
* The Spring MVC module's equivalent of {@link RestAssured}. This is the starting point of the DSL.
* <p>Note that some Javadoc is copied from Spring MVC's test documentation.</p>
*/
public class RestAssuredMockMvc {
/**
* Set a {@link org.springframework.test.web.servlet.MockMvc} instance that REST Assured will use when making requests unless overwritten
* by a {@link MockMvcRequestSpecification}.
*
* @param mockMvc The MockMvc instance to use.
*/
public static void mockMvc(MockMvc mockMvc) {
RestAssuredMockMvc.mockMvcFactory = new MockMvcFactory(mockMvc);
}
/**
* Define a REST Assured Mock Mvc configuration. E.g.
* <pre>
* given().config(newConfig().logConfig(new LogConfig(captor, true))). ..
* </pre>
* <p/>
* <code>newConfig()</code> can be statically imported from {@link RestAssuredMockMvcConfig}.
*/
public static RestAssuredMockMvcConfig config;
/**
* Specify a default request specification that will be sent with each request. E,g.
* <pre>
* RestAssuredMockMvc.requestSpecification = new MockMvcRequestSpecBuilder().addParam("parameter1", "value1").build();
* </pre>
* <p/>
* means that for each request by Rest Assured "parameter1" will be equal to "value1".
*/
public static MockMvcRequestSpecification requestSpecification;
/**
* Specify a default response specification that will be sent with each request. E,g.
* <pre>
* RestAssuredMockMvc.responseSpecification = new ResponseSpecBuilder().expectStatusCode(200).build();
* </pre>
* <p/>
* means that for each response Rest Assured will assert that the status code is equal to 200.
*/
public static ResponseSpecification responseSpecification = null;
private static List<ResultHandler> resultHandlers = new ArrayList<ResultHandler>();
private static List<RequestPostProcessor> requestPostProcessors = new ArrayList<RequestPostProcessor>();
private static MockMvcFactory mockMvcFactory = null;
/**
* The base path that's used by REST assured when making requests. The base path is prepended to the request path.
* Default value is <code>/</code>.
*/
public static String basePath = "/";
/**
* Defines a global authentication scheme that'll be used for all requests (if not overridden). Usage example:
* <pre>
* RestAssured.authentication = principal(myPrincipal);
* </pre>
*
* @see #principal(java.security.Principal)
* @see #principal(Object)
* @see #principalWithCredentials(Object, Object, String...)
* @see #authentication(Object)
*/
public static MockMvcAuthenticationScheme authentication;
/**
* This is usually the entry-point of the API if you need to specify parameters or a body in the request. For example:
* <p/>
* <pre>
* given().
* param("x", "y").
* when().
* get("/something").
* then().
* statusCode(200).
* body("x.y", notNullValue());
* </pre>
* Note that this method is the same as {@link #with()} but with another syntax.
*
* @return A {@link MockMvcRequestSpecification}.
*/
public static MockMvcRequestSpecification given() {
return new MockMvcRequestSpecificationImpl(mockMvcFactory, config, resultHandlers, requestPostProcessors, basePath, requestSpecification, responseSpecification, authentication);
}
/**
* This is usually the entry-point of the API if you need to specify parameters or a body in the request. For example:
* <p/>
* <pre>
* given().
* param("x", "y").
* when().
* get("/something").
* then().
* statusCode(200).
* body("x.y", notNullValue());
* </pre>
* <p/>
* Note that this method is the same as {@link #given()} but with another syntax.
*
* @return A {@link MockMvcRequestSpecification}.
*/
public static MockMvcRequestSpecification with() {
return given();
}
/**
* This is usually the entry-point of the API if you need to specify parameters or a body in the request. For example:
* <p/>
* <pre>
* when().
* get("/x").
* then().
* body("x.y.z1", equalTo("Z1")).
* body("x.y.z2", equalTo("Z2"));
* </pre>
* <p>
* Note that if you need to add parameters, headers, cookies or other request properties use the {@link #given()} method.
* </p>
*
* @return A request sender interface that let's you call resources on the server
*/
public static MockMvcRequestSender when() {
return given().when();
}
/**
* Build a {@link MockMvc} by registering one or more {@code @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.
* <p/>
* <p>When this option is used, the minimum infrastructure required by the
* {@link 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.
* <p/>
* <p>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.
*
* @param controllersOrMockMvcConfigurers one or more {@link org.springframework.stereotype.Controller @Controller}'s to test as well
* as @{link MockMvcConfigurer}'s to apply
*/
public static void standaloneSetup(Object... controllersOrMockMvcConfigurers) {
mockMvcFactory = StandaloneMockMvcFactory.of(controllersOrMockMvcConfigurers);
}
/**
* Build a {@link MockMvc} by using a provided {@code 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.
* <p/>
* <p>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.
*
* @param builder {@link org.springframework.test.web.servlet.setup.AbstractMockMvcBuilder} to build the MVC mock
*/
public static void standaloneSetup(MockMvcBuilder builder) {
mockMvcFactory = new MockMvcFactory(builder);
}
/**
* Build a {@link MockMvc} using the given, fully initialized, i.e.
* refreshed, {@link WebApplicationContext} and assign it to REST Assured.
* The {@link 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 {@link javax.servlet.ServletContext}.
*
* @param context The web application context to use
* @param mockMvcConfigurers {@link MockMvcConfigurer}'s to be applied when creating a {@link MockMvc} instance of this WebApplicationContext (optional)
*/
public static void webAppContextSetup(WebApplicationContext context, MockMvcConfigurer... mockMvcConfigurers) {
DefaultMockMvcBuilder builder = MockMvcBuilders.webAppContextSetup(context); // To avoid compile-time errors
if (mockMvcConfigurers != null && mockMvcConfigurers.length > 0) {
for (MockMvcConfigurer mockMvcConfigurer : mockMvcConfigurers) {
builder.apply(mockMvcConfigurer);
}
}
mockMvcFactory = new MockMvcFactory(builder);
}
/**
* Assign one or more {@link org.springframework.test.web.servlet.ResultHandler} that'll be executes after a request has been made.
*
* @param resultHandler The result handler
* @param resultHandlers Additional result handlers (optional)
*/
public static void resultHandlers(ResultHandler resultHandler, ResultHandler... resultHandlers) {
notNull(resultHandler, ResultHandler.class);
RestAssuredMockMvc.resultHandlers.add(resultHandler);
if (resultHandlers != null && resultHandlers.length >= 1) {
Collections.addAll(RestAssuredMockMvc.resultHandlers, resultHandlers);
}
}
/**
* @return The defined list of result handlers
*/
public static List<ResultHandler> resultHandlers() {
return Collections.unmodifiableList(resultHandlers);
}
/**
* Assign one or more {@link org.springframework.test.web.servlet.ResultHandler} that'll be executes after a request has been made.
* <p>
* Note that it's recommended to use {@link #with(RequestPostProcessor, RequestPostProcessor...)} instead of this method when setting
* authentication/authorization based RequestPostProcessors.
* </p>
*
* @param postProcessor a post-processor to add
* @param additionalPostProcessors Additional post-processors to add
* @see MockMvcRequestSpecification#postProcessors(RequestPostProcessor, RequestPostProcessor...)
*/
public static void postProcessors(RequestPostProcessor postProcessor, RequestPostProcessor... additionalPostProcessors) {
notNull(postProcessor, RequestPostProcessor.class);
RestAssuredMockMvc.requestPostProcessors.add(postProcessor);
if (additionalPostProcessors != null && additionalPostProcessors.length >= 1) {
Collections.addAll(RestAssuredMockMvc.requestPostProcessors, additionalPostProcessors);
}
}
/**
* @return The defined list of request post processors
*/
public static List<RequestPostProcessor> postProcessors() {
return Collections.unmodifiableList(requestPostProcessors);
}
/**
* Reset all static configurations to their default values.
*/
public static void reset() {
mockMvcFactory = null;
config = null;
basePath = "/";
resultHandlers.clear();
requestPostProcessors.clear();
responseSpecification = null;
requestSpecification = null;
authentication = null;
}
/**
* Perform a GET request to a <code>path</code>. Normally the path doesn't have to be fully-qualified e.g. you don't need to
* specify the path as <tt>http://localhost:8080/path</tt>. In this case it's enough to use <tt>/path</tt>.
*
* @param path The path to send the request to.
* @param pathParams The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do <code>get("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);</code>.
* @return The response of the GET request.
*/
public static MockMvcResponse get(String path, Object... pathParams) {
return given().get(path, pathParams);
}
/**
* Perform a GET request to a <code>path</code>. Normally the path doesn't have to be fully-qualified e.g. you don't need to
* specify the path as <tt>http://localhost:8080/path</tt>. In this case it's enough to use <tt>/path</tt>.
*
* @param path The path to send the request to.
* @param pathParams The path parameters.
* @return The response of the GET request.
*/
public static MockMvcResponse get(String path, Map<String, ?> pathParams) {
return given().get(path, pathParams);
}
/**
* Perform a POST request to a <code>path</code>. Normally the path doesn't have to be fully-qualified e.g. you don't need to
* specify the path as <tt>http://localhost:8080/path</tt>. In this case it's enough to use <tt>/path</tt>.
*
* @param path The path to send the request to.
* @param pathParams The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do <code>post("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);</code>.
* @return The response of the request.
*/
public static MockMvcResponse post(String path, Object... pathParams) {
return given().post(path, pathParams);
}
/**
* Perform a POST request to a <code>path</code>. Normally the path doesn't have to be fully-qualified e.g. you don't need to
* specify the path as <tt>http://localhost:8080/path</tt>. In this case it's enough to use <tt>/path</tt>.
*
* @param path The path to send the request to.
* @param pathParams The path parameters.
* @return The response of the request.
*/
public static MockMvcResponse post(String path, Map<String, ?> pathParams) {
return given().post(path, pathParams);
}
/**
* Perform a PUT request to a <code>path</code>. Normally the path doesn't have to be fully-qualified e.g. you don't need to
* specify the path as <tt>http://localhost:8080/path</tt>. In this case it's enough to use <tt>/path</tt>.
*
* @param path The path to send the request to.
* @param pathParams The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do <code>put("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);</code>.
* @return The response of the request.
*/
public static MockMvcResponse put(String path, Object... pathParams) {
return given().put(path, pathParams);
}
/**
* Perform a DELETE request to a <code>path</code>. Normally the path doesn't have to be fully-qualified e.g. you don't need to
* specify the path as <tt>http://localhost:8080/path</tt>. In this case it's enough to use <tt>/path</tt>.
*
* @param path The path to send the request to.
* @param pathParams The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do <code>delete("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);</code>.
* @return The response of the request.
*/
public static MockMvcResponse delete(String path, Object... pathParams) {
return given().delete(path, pathParams);
}
/**
* Perform a DELETE request to a <code>path</code>. Normally the path doesn't have to be fully-qualified e.g. you don't need to
* specify the path as <tt>http://localhost:8080/path</tt>. In this case it's enough to use <tt>/path</tt>.
*
* @param path The path to send the request to.
* @param pathParams The path parameters.
* @return The response of the request.
*/
public static MockMvcResponse delete(String path, Map<String, ?> pathParams) {
return given().delete(path, pathParams);
}
/**
* Perform a HEAD request to a <code>path</code>. Normally the path doesn't have to be fully-qualified e.g. you don't need to
* specify the path as <tt>http://localhost:8080/path</tt>. In this case it's enough to use <tt>/path</tt>.
*
* @param path The path to send the request to.
* @param pathParams The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do <code>head("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);</code>.
* @return The response of the request.
*/
public static MockMvcResponse head(String path, Object... pathParams) {
return given().head(path, pathParams);
}
/**
* Perform a HEAD request to a <code>path</code>. Normally the path doesn't have to be fully-qualified e.g. you don't need to
* specify the path as <tt>http://localhost:8080/path</tt>. In this case it's enough to use <tt>/path</tt>.
*
* @param path The path to send the request to.
* @param pathParams The path parameters.
* @return The response of the request.
*/
public static MockMvcResponse head(String path, Map<String, ?> pathParams) {
return given().head(path, pathParams);
}
/**
* Perform a PATCH request to a <code>path</code>. Normally the path doesn't have to be fully-qualified e.g. you don't need to
* specify the path as <tt>http://localhost:8080/path</tt>. In this case it's enough to use <tt>/path</tt>.
*
* @param path The path to send the request to.
* @param pathParams The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do <code>head("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);</code>.
* @return The response of the request.
*/
public static MockMvcResponse patch(String path, Object... pathParams) {
return given().patch(path, pathParams);
}
/**
* Perform a PATCH request to a <code>path</code>. Normally the path doesn't have to be fully-qualified e.g. you don't need to
* specify the path as <tt>http://localhost:8080/path</tt>. In this case it's enough to use <tt>/path</tt>.
*
* @param path The path to send the request to.
* @param pathParams The path parameters.
* @return The response of the request.
*/
public static MockMvcResponse patch(String path, Map<String, ?> pathParams) {
return given().patch(path, pathParams);
}
/**
* Perform a OPTIONS request to a <code>path</code>. Normally the path doesn't have to be fully-qualified e.g. you don't need to
* specify the path as <tt>http://localhost:8080/path</tt>. In this case it's enough to use <tt>/path</tt>.
*
* @param path The path to send the request to.
* @param pathParams The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do <code>head("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);</code>.
* @return The response of the request.
*/
public static MockMvcResponse options(String path, Object... pathParams) {
return given().options(path, pathParams);
}
/**
* Perform a OPTIONS request to a <code>path</code>. Normally the path doesn't have to be fully-qualified e.g. you don't need to
* specify the path as <tt>http://localhost:8080/path</tt>. In this case it's enough to use <tt>/path</tt>.
*
* @param path The path to send the request to.
* @param pathParams The path parameters.
* @return The response of the request.
*/
public static MockMvcResponse options(String path, Map<String, ?> pathParams) {
return given().options(path, pathParams);
}
/**
* Perform a GET request to a <code>uri</code>.
*
* @param uri The uri to send the request to.
* @return The response of the GET request.
*/
public static MockMvcResponse get(URI uri) {
return given().get(uri);
}
/**
* Perform a POST request to a <code>uri</code>.
*
* @param uri The uri to send the request to.
* @return The response of the request.
*/
public static MockMvcResponse post(URI uri) {
return given().post(uri);
}
/**
* Perform a PUT request to a <code>uri</code>.
*
* @param uri The uri to send the request to.
* @return The response of the request.
*/
public static MockMvcResponse put(URI uri) {
return given().put(uri);
}
/**
* Perform a DELETE request to a <code>uri</code>.
*
* @param uri The uri to send the request to.
* @return The response of the request.
*/
public static MockMvcResponse delete(URI uri) {
return given().delete(uri);
}
/**
* Perform a HEAD request to a <code>uri</code>.
*
* @param uri The uri to send the request to.
* @return The response of the request.
*/
public static MockMvcResponse head(URI uri) {
return given().head(uri);
}
/**
* Perform a PATCH request to a <code>uri</code>.
*
* @param uri The uri to send the request to.
* @return The response of the request.
*/
public static MockMvcResponse patch(URI uri) {
return given().patch(uri);
}
/**
* Perform a OPTIONS request to a <code>uri</code>.
*
* @param uri The uri to send the request to.
* @return The response of the request.
*/
public static MockMvcResponse options(URI uri) {
return given().options(uri);
}
/**
* Perform a GET request to a <code>url</code>.
*
* @param url The url to send the request to.
* @return The response of the GET request.
*/
public static MockMvcResponse get(URL url) {
return given().get(url);
}
/**
* Perform a POST request to a <code>url</code>.
*
* @param url The url to send the request to.
* @return The response of the request.
*/
public static MockMvcResponse post(URL url) {
return given().post(url);
}
/**
* Perform a PUT request to a <code>url</code>.
*
* @param url The url to send the request to.
* @return The response of the request.
*/
public static MockMvcResponse put(URL url) {
return given().put(url);
}
/**
* Perform a DELETE request to a <code>url</code>.
*
* @param url The url to send the request to.
* @return The response of the request.
*/
public static MockMvcResponse delete(URL url) {
return given().delete(url);
}
/**
* Perform a HEAD request to a <code>url</code>.
*
* @param url The url to send the request to.
* @return The response of the request.
*/
public static MockMvcResponse head(URL url) {
return given().head(url);
}
/**
* Perform a PATCH request to a <code>url</code>.
*
* @param url The url to send the request to.
* @return The response of the request.
*/
public static MockMvcResponse patch(URL url) {
return given().patch(url);
}
/**
* Perform a OPTIONS request to a <code>url</code>.
*
* @param url The url to send the request to.
* @return The response of the request.
*/
public static MockMvcResponse options(URL url) {
return given().options(url);
}
/**
* Perform a GET request to the statically configured base path.
*
* @return The response of the GET request.
*/
public static MockMvcResponse get() {
return given().get();
}
/**
* Perform a POST request to the statically configured base path.
*
* @return The response of the request.
*/
public static MockMvcResponse post() {
return given().post();
}
/**
* Perform a PUT request to the statically configured base path.
*
* @return The response of the request.
*/
public static MockMvcResponse put() {
return given().put();
}
/**
* Perform a DELETE request to the statically configured base path.
*
* @return The response of the request.
*/
public static MockMvcResponse delete() {
return given().delete();
}
/**
* Perform a HEAD request to the statically configured base path.
*
* @return The response of the request.
*/
public static MockMvcResponse head() {
return given().head();
}
/**
* Perform a PATCH request to the statically configured base path.
*
* @return The response of the request.
*/
public static MockMvcResponse patch() {
return given().patch();
}
/**
* Perform a OPTIONS request to the statically configured base path.
*
* @return The response of the request.
*/
public static MockMvcResponse options() {
return given().options();
}
/**
* Perform a request to the pre-configured path (by default <code>http://localhost:8080</code>).
*
* @param method The HTTP method to use
* @return The response of the request.
*/
public static MockMvcResponse request(Method method) {
return given().request(method);
}
/**
* Perform a custom HTTP request to the pre-configured path (by default <code>http://localhost:8080</code>).
*
* @param method The HTTP method to use
* @return The response of the request.
*/
public static MockMvcResponse request(String method) {
return given().request(method);
}
/**
* Perform a HTTP request to a <code>path</code>. Normally the path doesn't have to be fully-qualified e.g. you don't need to
* specify the path as <tt>http://localhost:8080/path</tt>. In this case it's enough to use <tt>/path</tt>.
*
* @param method The HTTP method to use
* @param path The path to send the request to.
* @param pathParams The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do <code>request(Method.TRACE,"/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);</code>.
* @return The response of the request.
*/
public static MockMvcResponse request(Method method, String path, Object... pathParams) {
return given().request(method, path, pathParams);
}
/**
* Perform a custom HTTP request to a <code>path</code>. Normally the path doesn't have to be fully-qualified e.g. you don't need to
* specify the path as <tt>http://localhost:8080/path</tt>. In this case it's enough to use <tt>/path</tt>.
*
* @param method The HTTP method to use
* @param path The path to send the request to.
* @param pathParams The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do <code>request("method","/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);</code>.
* @return The response of the request.
*/
public static MockMvcResponse request(String method, String path, Object... pathParams) {
return given().request(method, path, pathParams);
}
/**
* Perform a request to a <code>uri</code>.
*
* @param method The HTTP method to use
* @param uri The uri to send the request to.
* @return The response of the GET request.
*/
public static MockMvcResponse request(Method method, URI uri) {
return given().request(method, uri);
}
/**
* Perform a request to a <code>url</code>.
*
* @param method The HTTP method to use
* @param url The url to send the request to.
* @return The response of the GET request.
*/
public static MockMvcResponse request(Method method, URL url) {
return given().request(method, url);
}
/**
* Perform a custom HTTP request to a <code>uri</code>.
*
* @param method The HTTP method to use
* @param uri The uri to send the request to.
* @return The response of the GET request.
*/
public static MockMvcResponse request(String method, URI uri) {
return given().request(method, uri);
}
/**
* Perform a custom HTTP request to a <code>url</code>.
*
* @param method The HTTP method to use
* @param url The url to send the request to.
* @return The response of the GET request.
*/
public static MockMvcResponse request(String method, URL url) {
return given().request(method, url);
}
/**
* Authenticate using the given principal. Used as:
* <pre>
* RestAssured.authentication = principal(myPrincipal);
* </pre>
* or in a {@link MockMvcRequestSpecBuilder}:
* <pre>
* MockMvcRequestSpecification req = new MockMvcRequestSpecBuilder().setAuth(principal(myPrincipal)). ..
* </pre>
*
* @param principal The principal to use.
* @return A {@link MockMvcAuthenticationScheme} instance.
* @see MockMvcAuthenticationSpecification#principal(java.security.Principal)
*/
public static MockMvcAuthenticationScheme principal(final Principal principal) {
return new MockMvcAuthenticationScheme() {
public void authenticate(MockMvcRequestSpecification mockMvcRequestSpecification) {
mockMvcRequestSpecification.auth().principal(principal);
}
};
}
/**
* Authenticate using the given principal. Used as:
* <pre>
* RestAssured.authentication = principal(myPrincipal);
* </pre>
* or in a {@link MockMvcRequestSpecBuilder}:
* <pre>
* MockMvcRequestSpecification req = new MockMvcRequestSpecBuilder().setAuth(principal(myPrincipal)). ..
* </pre>
*
* @param principal The principal to use.
* @return A {@link MockMvcAuthenticationScheme} instance.
* @see MockMvcAuthenticationSpecification#principal(Object)
*/
public static MockMvcAuthenticationScheme principal(final Object principal) {
return new MockMvcAuthenticationScheme() {
public void authenticate(MockMvcRequestSpecification mockMvcRequestSpecification) {
mockMvcRequestSpecification.auth().principal(principal);
}
};
}
/**
* Authenticate using the given principal and credentials. Used as:
* <pre>
* RestAssured.authentication = principalWithCredentials(myPrincipal, myCredentials);
* </pre>
* or in a {@link MockMvcRequestSpecBuilder}:
* <pre>
* MockMvcRequestSpecification req = new MockMvcRequestSpecBuilder().setAuth(principalWithCredentials(myPrincipal, myCredentials)). ..
* </pre>
*
* @param principal The principal to use.
* @param credentials The credentials to use
* @param authorities Optional list of authorities
* @return A {@link MockMvcAuthenticationScheme} instance.
* @see MockMvcAuthenticationSpecification#principalWithCredentials(Object, Object, String...)
*/
public static MockMvcAuthenticationScheme principalWithCredentials(final Object principal, final Object credentials, final String... authorities) {
return new MockMvcAuthenticationScheme() {
public void authenticate(MockMvcRequestSpecification mockMvcRequestSpecification) {
mockMvcRequestSpecification.auth().principalWithCredentials(principal, credentials, authorities);
}
};
}
/**
* Authenticate using the supplied authentication instance (<code>org.springframework.security.core.Authentication</code> from Spring Security). Used as:
* <pre>
* RestAssured.authentication = authentication(myAuth);
* </pre>
* or in a {@link MockMvcRequestSpecBuilder}:
* <pre>
* MockMvcRequestSpecification req = new MockMvcRequestSpecBuilder().setAuth(authentication(myAuth)). ..
* </pre>
*
* @param authentication The authentication instance to use.
* @return A {@link MockMvcAuthenticationScheme} instance.
* @see MockMvcAuthenticationSpecification#authentication(Object)
*/
public static MockMvcAuthenticationScheme authentication(final Object authentication) {
return new MockMvcAuthenticationScheme() {
public void authenticate(MockMvcRequestSpecification mockMvcRequestSpecification) {
mockMvcRequestSpecification.auth().authentication(authentication);
}
};
}
/**
* Authenticate using a {@link RequestPostProcessor}.
* This is mainly useful when you have added the <code>spring-security-test</code> artifact to classpath. This allows
* you to do for example:
* <pre>
* RestAssured.authentication = with(user("username").password("password"));
* </pre>
* where <code>user</code> is statically imported from <code>org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors</code>.
*
* @param requestPostProcessor The first request post processor to be used for authentication
* @param additionalRequestPostProcessor Additional request post processors to be used for authentication
* @return A {@link MockMvcAuthenticationScheme} instance.
*/
public static MockMvcAuthenticationScheme with(final RequestPostProcessor requestPostProcessor, final RequestPostProcessor... additionalRequestPostProcessor) {
return new MockMvcAuthenticationScheme() {
public void authenticate(MockMvcRequestSpecification mockMvcRequestSpecification) {
mockMvcRequestSpecification.auth().with(requestPostProcessor, additionalRequestPostProcessor);
}
};
}
/**
* Enable logging of both the request and the response if REST Assureds test validation fails with log detail equal to {@link LogDetail#ALL}.
* <p/>
* <p>
* This is just a shortcut for:
* </p>
* <pre>
* RestAssuredMockMvc.config = new RestAssuredMockMvcConfig().logConfig(logConfig().enableLoggingOfRequestAndResponseIfValidationFails());
* </pre>
*/
public static void enableLoggingOfRequestAndResponseIfValidationFails() {
enableLoggingOfRequestAndResponseIfValidationFails(LogDetail.ALL);
}
/**
* Enable logging of both the request and the response if REST Assureds test validation fails with the specified log detail.
* <p/>
* <p>
* This is just a shortcut for:
* </p>
* <pre>
* RestAssured.config = new RestAssuredMockMvcConfig().logConfig(logConfig().enableLoggingOfRequestAndResponseIfValidationFails(logDetail));
* </pre>
*
* @param logDetail The log detail to show in the log
*/
public static void enableLoggingOfRequestAndResponseIfValidationFails(LogDetail logDetail) {
config = config == null ? new RestAssuredMockMvcConfig() : config;
config = config.logConfig(logConfig().enableLoggingOfRequestAndResponseIfValidationFails(logDetail));
// Update request specification if already defined otherwise it'll override the configs.
// Note that request spec also influence response spec when it comes to logging if validation fails due to the way filters work
if (requestSpecification != null && requestSpecification instanceof MockMvcRequestSpecificationImpl) {
RestAssuredMockMvcConfig restAssuredConfig = ((MockMvcRequestSpecificationImpl) requestSpecification).getRestAssuredMockMvcConfig();
if (restAssuredConfig == null) {
restAssuredConfig = config;
} else {
LogConfig logConfigForRequestSpec = restAssuredConfig.getLogConfig().enableLoggingOfRequestAndResponseIfValidationFails(logDetail);
restAssuredConfig = restAssuredConfig.logConfig(logConfigForRequestSpec);
}
requestSpecification.config(restAssuredConfig);
}
}
/**
* @return The assigned config or a new config is no config is assigned
*/
public static RestAssuredMockMvcConfig config() {
return config == null ? new RestAssuredMockMvcConfig() : config;
}
}