Response Actions
Response actions contain:
- status code i.e. 200, 302, 404, etc
- body - a UTF-8 encoded sequence of bytes containing any content
- headers - each with a name and one or more values
- cookies - each with a name and with one or more values, more complex cookies can be modelled by using the a Set-Cookie header
Responses can be further controlled using:
- a delay before the response is sent
- the number of times the response is sent (including unlimited)
- a time to live the response will be continued to be returned (including unlimited)
Java
When mocking a response in Java use the org.mockserver.model.HttpResponse class which specifies the details of each HTTP response with a fluent API, for example:
HttpResponse httpResponse =
response()
.withStatusCode(401)
.withHeaders(
new Header("Content-Type", "application/json; charset=utf-8"),
new Header("Cache-Control", "public, max-age=86400")
)
.withBody("{ message: 'incorrect username and password combination' }")
.withDelay(new Delay(TimeUnit.SECONDS, 1))
.withConnectionOptions(
new ConnectionOptions()
.withKeepAliveOverride(true)
.withCloseSocket(true)
);
The full specification of org.mockserver.model.HttpResponse is as follows:
public class HttpResponse {
/**
* The status code to return, such as 200, 404, the status code specified
* here will result in the default status message for this status code for
* example for 200 the status message "OK" is used
*
* @param statusCode an integer such as 200 or 404
*/
public HttpResponse withStatusCode(Integer responseCode);
/**
* The cookies to return as Set-Cookie headers as a list of Cookie objects
*
* @param cookies a list of Cookie objects
*/
public HttpResponse withCookies(List<Cookie> cookies);
/**
* The cookies to return as Set-Cookie headers as a varargs of Cookie objects
*
* @param cookies a varargs of Cookie objects
*/
public HttpResponse withCookies(Cookie... cookies);
/**
* Add cookie to return as Set-Cookie header
*
* @param cookie a Cookie object
*/
public HttpResponse withCookie(Cookie cookie);
/**
* Add cookie to return as Set-Cookie header
*
* @param name the cookies name
* @param value the cookies value which can be a string or regular expression
*/
public HttpResponse withCookie(String name, String value);
/**
* The headers to return as a list of Header objects
*
* @param headers a list of Header objects
*/
public HttpResponse withHeaders(List<Header> headers);
/**
* The headers to return as a varargs of Header objects
*
* @param headers a varargs of Header objects
*/
public HttpResponse withHeaders(Header... headers);
/**
* A header to return as a Header objects
*
* @param header a Header objects
*/
public HttpResponse withHeader(Header header)
/**
* A header to return as a Header objects
*
* @param name the header name
* @param values the header values which can be a varags of strings or regular expressions
*/
public HttpResponse withHeader(String name, String... values)
/**
* Set response body to return as a simple UTF-8 string response body
*
* @param body a "UTF-8" string
*/
public HttpResponse withBody(String body);
/**
* * Set response body to return as binary such as a pdf or image
*
* @param body a byte array
*/
public HttpResponse withBody(byte[] body);
/**
* Set the body to return for example:
*
* string body:
* - exact("<html><head/><body><div>a simple string body</div></body></html>"); or
* - new StringBody("<html><head/><body><div>a simple string body</div></body></html>")
*
* binary body:
* - binary(IOUtils.readFully(getClass().getClassLoader().getResourceAsStream("example.pdf"), 1024)); or
* - new BinaryBody(IOUtils.readFully(getClass().getClassLoader().getResourceAsStream("example.pdf"), 1024));
*
* @param body an instance of one of the Body subclasses including StringBody or BinaryBody
*/
public HttpResponse withBody(Body body);
/**
* The delay before responding with this request as a Delay object, for example new Delay(TimeUnit.SECONDS, 3)
*
* @param delay a Delay object, for example new Delay(TimeUnit.SECONDS, 3)
*/
public HttpResponse withDelay(Delay delay);
/**
* The connection options for override the default connection behaviour, this allows full control of headers such
* as "Connection" or "Content-Length" or controlling whether the socket is closed after the response has been sent
*
* @param connectionOptions the connection options for override the default connection behaviour
*/
public HttpResponse withConnectionOptions(ConnectionOptions connectionOptions);
}To control whether the socket is closed after the response has been sent or headers such as "Connection" or "Content-Length" the org.mockserver.model.ConnectionOptions class can be used, as follows:
public class ConnectionOptions {
/**
* Prevent a "Content-Length" header from being added to the response
*
* @param suppressContentLengthHeader if true no "Content-Length" header will be added to the response
*/
public ConnectionOptions withSuppressContentLengthHeader(Boolean suppressContentLengthHeader);
/**
* Override the "Content-Length" header with the specified amount, if not set the "Content-Length"
* header will have a value determined by the length of the body
*
* @param contentLengthHeaderOverride the value to use for the "Content-Length" header
*/
public ConnectionOptions withContentLengthHeaderOverride(Integer contentLengthHeaderOverride);
/**
* Prevent a "Connection" header from being added to the response
*
* @param suppressConnectionHeader if true no "Connection" header will be added to the response
*/
public ConnectionOptions withSuppressConnectionHeader(Boolean suppressConnectionHeader);
/**
* Override the "Connection" header:
* if true the "Connection" header is specified with a value of "keep-alive"
* if false the "Connection" header is specified with a value of "close"
* if not set the "Connection" header will have a a value of "close" unless the request received is HTTP 1.1 and contains a "Connection" header with a value of "keep-alive"
*
* @param keepAliveOverride if true "keep-alive" is used if false "close" is used for the "Connection" header
*/
public ConnectionOptions withKeepAliveOverride(Boolean keepAliveOverride);
/**
* Override whether the socket is closed after a response is sent:
* if true the socket will always be closed,
* if false the socket will never be closed,
* if not set the socket will be closed unless the request received is HTTP 1.1 and contains a "Connection" header with a value of "keep-alive"
*
* @param closeSocket set whether the socket is closed after a response is sent
*/
public ConnectionOptions withCloseSocket(Boolean closeSocket);
}For example:
HttpResponse httpResponse =
response()
.withStatusCode(401)
.withHeaders(
new Header("Content-Type", "application/json; charset=utf-8"),
new Header("Cache-Control", "public, max-age=86400")
)
.withBody("{ message: 'incorrect username and password combination' }")
.withDelay(new Delay(TimeUnit.SECONDS, 1))
.withConnectionOptions(
new ConnectionOptions()
.withKeepAliveOverride(true)
.withCloseSocket(true)
);
JavaScript
To mock a response in javascript use JSON to specify the details with the following format:
"httpResponse": {
"statusCode": 200,
"body": "",
"cookies": [],
"headers": [],
"delay": {
"timeUnit": "MICROSECONDS",
"value": 0
}
}
Each cookie or header array entry has the following syntax:
{
"name": "someName",
"values": ["someValueOne", "someValueTwo", ...]
}The "timeUnit" value in "delay" can be:
"NANOSECONDS"
"MICROSECONDS"
"MILLISECONDS"
"SECONDS"
"MINUTES"
"HOURS"
"DAYS"The same example as above would be:
"httpResponse": {
"statusCode": 401,
"headers": [
{
"name": "Content-Type",
"values": ["application/json; charset=utf-8"]
},
{
"name": "Cache-Control",
"values": ["public, max-age=86400"]
}
],
"body": JSON.stringify({ message: "incorrect username and password combination" }),
"delay": {
"timeUnit": "SECONDS",
"value": 1
}
}