Package org.mockserver.model

Class HttpRequest

    • Constructor Detail

      • HttpRequest

        public HttpRequest()

    • Method Detail

      • isKeepAlive

        public Boolean isKeepAlive()

      • withKeepAlive

        public HttpRequest withKeepAlive​(Boolean isKeepAlive)
        Match on whether the request was made using an HTTP persistent connection, also called HTTP keep-alive, or HTTP connection reuse
        Parameters:
        isKeepAlive - true if the request was made with an HTTP persistent connection

      • isSecure

        public Boolean isSecure()

      • withSecure

        public HttpRequest withSecure​(Boolean isSecure)
        Match on whether the request was made over TLS or SSL (i.e. HTTPS)
        Parameters:
        isSecure - true if the request was made with TLS or SSL

      • getRespondBeforeBody

        public Boolean getRespondBeforeBody()

      • withRespondBeforeBody

        public HttpRequest withRespondBeforeBody​(Boolean respondBeforeBody)
        Match this request without waiting for the body to be received, and send the configured response before the body is consumed. Matchers with respondBeforeBody=true must not specify a body matcher and must use a RESPONSE or ERROR action; combine with connectionOptions.closeSocket=true on the response to close the connection after the response is sent. Useful for testing client behaviour when a server responds and closes mid-upload.
        Parameters:
        respondBeforeBody - true to dispatch the matched response before the request body is read

      • getProtocol

        public Protocol getProtocol()

      • withProtocol

        public HttpRequest withProtocol​(Protocol protocol)
        Match on whether the request was made over HTTP or HTTP2
        Parameters:
        protocol - used to indicate HTTP or HTTP2

      • getStreamId

        public Integer getStreamId()

      • withStreamId

        public HttpRequest withStreamId​(Integer streamId)
        HTTP2 stream id request was received on
        Parameters:
        streamId - HTTP2 stream id request was received on

      • withSocketAddress

        public HttpRequest withSocketAddress​(SocketAddress socketAddress)
        Specify remote address if the remote address can't be derived from the host header, if no value is specified the host header will be used to determine remote address
        Parameters:
        socketAddress - the remote address to send request to

      • withSocketAddress

        public HttpRequest withSocketAddress​(String host,
                                     Integer port,
                                     SocketAddress.Scheme scheme)
        Specify remote address if the remote address can't be derived from the host header, if no value is specified the host header will be used to determine remote address
        Parameters:
        host - the remote host or ip to send request to
        port - the remote port to send request to
        scheme - the scheme to use for remote socket

      • withSocketAddress

        public HttpRequest withSocketAddress​(String host,
                                     Integer port)
        Specify remote address by attempting to derive it from the host header and / or the specified port
        Parameters:
        host - the remote host or ip to send request to
        port - the remote port to send request to

      • withSocketAddressFromHostHeader

        public HttpRequest withSocketAddressFromHostHeader()
        Specify remote address by attempting to derive it from the host header

      • withSocketAddress

        public HttpRequest withSocketAddress​(Boolean isSecure,
                                     String host,
                                     Integer port)
        Specify remote address by attempting to derive it from the host header and / or the specified port
        Parameters:
        isSecure - true if the request was made with TLS or SSL
        host - the remote host or ip to send request to
        port - the remote port to send request to

      • splitHostPort

        public static String[] splitHostPort​(String hostPort)

      • getLocalAddress

        public String getLocalAddress()

      • getRemoteAddress

        public String getRemoteAddress()

      • withMethod

        public HttpRequest withMethod​(String method)
        The HTTP method to match on such as "GET" or "POST"
        Parameters:
        method - the HTTP method such as "GET" or "POST"

      • withMethodSchema

        public HttpRequest withMethodSchema​(String method)
        The HTTP method to match on as a JSON Schema for example: 
         {
     "type": "string",
     "minLength": 2,
     "maxLength": 3
 }

 or

 {
     "type": "string",
     "pattern": "^P.{2,3}$"
 }

 or

 {
     "type": "string",
     "format": "ipv4"
 }

        For full details of JSON Schema see, https://json-schema.org/understanding-json-schema/reference/string.html

        Parameters:
        method - the HTTP method to match on as a JSON Schema

      • withMethod

        public HttpRequest withMethod​(NottableString method)
        The HTTP method all method except a specific value using the "not" operator, for example this allows operations such as not("GET")
        Parameters:
        method - the HTTP method to not match on not("GET") or not("POST")

      • getMethod

        public String getMethod​(String defaultValue)

      • withPath

        public HttpRequest withPath​(String path)
        The path to match on such as "/some_mocked_path" any servlet context path is ignored for matching and should not be specified here regex values are also supported such as ".*_path", see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html for full details of the supported regex syntax
        Parameters:
        path - the path such as "/some_mocked_path" or a regex

      • withPath

        public HttpRequest withPath​(NottableString path)
        The path to not match on for example not("/some_mocked_path") with match any path not equal to "/some_mocked_path", the servlet context path is ignored for matching and should not be specified hereregex values are also supported such as not(".*_path"), see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html for full details of the supported regex syntax
        Parameters:
        path - the path to not match on such as not("/some_mocked_path") or not(".*_path")

      • withPathSchema

        public HttpRequest withPathSchema​(String path)
        The path to match on as a JSON Schema for example: 
         {
     "type": "string",
     "minLength": 2,
     "maxLength": 3
 }

 or

 {
     "type": "string",
     "pattern": "^simp.{2}$"
 }

 or

 {
     "type": "string",
     "format": "ipv4"
 }

        For full details of JSON Schema see, https://json-schema.org/understanding-json-schema/reference/string.html

        Parameters:
        path - the path to match on as a JSON Schema

      • matches

        public boolean matches​(String method)

      • matches

        public boolean matches​(String method,
                       String... paths)

      • getPathParameters

        public Parameters getPathParameters()

      • withPathParameters

        public HttpRequest withPathParameters​(List<Parameter> parameters)
        The path parameter to match on as a list of Parameter objects where the values or keys of each parameter can be either a string or a regex (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Parameters:
        parameters - the list of Parameter objects where the values or keys of each parameter can be either a string or a regex

      • withPathParameters

        public HttpRequest withPathParameters​(Parameter... parameters)
        The path parameter to match on as a varags Parameter objects where the values or keys of each parameter can be either a string or a regex (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Parameters:
        parameters - the varags Parameter objects where the values or keys of each parameter can be either a string or a regex

      • withPathParameters

        public HttpRequest withPathParameters​(Map<String,​List<String>> parameters)
        The path parameter to match on as a Map<String, List<String>> where the values or keys of each parameter can be either a string or a regex (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Parameters:
        parameters - the Map<String, List<String>> object where the values or keys of each parameter can be either a string or a regex

      • withPathParameter

        public HttpRequest withPathParameter​(Parameter parameter)
        Adds one path parameter to match on as a Parameter object where the parameter values list can be a list of strings or regular expressions (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Parameters:
        parameter - the Parameter object which can have a values list of strings or regular expressions

      • withPathParameter

        public HttpRequest withPathParameter​(String name,
                                     String... values)
        Adds one path parameter to match which can specified using plain strings or regular expressions (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Parameters:
        name - the parameter name
        values - the parameter values which can be a varags of strings or regular expressions

      • withSchemaPathParameter

        public HttpRequest withSchemaPathParameter​(String name,
                                           String... values)
        Adds one path parameter to match which the values are JSON schema i.e. "{ \"type\": \"string\", \"pattern\": \"^someV[a-z]{4}$\" }" (for more details of the supported JSON schema see https://json-schema.org)
        Parameters:
        name - the parameter name
        values - the parameter values which can be a varags of JSON schemas

      • withPathParameter

        public HttpRequest withPathParameter​(NottableString name,
                                     NottableString... values)
        Adds one path parameter to match on or to not match on using the NottableString, each NottableString can either be a positive matching value, such as string("match"), or a value to not match on, such as not("do not match"), the string values passed to the NottableString can also be a plain string or a regex (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Parameters:
        name - the parameter name as a NottableString
        values - the parameter values which can be a varags of NottableStrings

      • getPathParameterList

        public List<Parameter> getPathParameterList()

      • hasPathParameter

        public boolean hasPathParameter​(String name,
                                String value)

      • getFirstPathParameter

        public String getFirstPathParameter​(String name)

      • getQueryStringParameters

        public Parameters getQueryStringParameters()

      • withQueryStringParameters

        public HttpRequest withQueryStringParameters​(List<Parameter> parameters)
        The query string parameters to match on as a list of Parameter objects where the values or keys of each parameter can be either a string or a regex (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Parameters:
        parameters - the list of Parameter objects where the values or keys of each parameter can be either a string or a regex

      • withQueryStringParameters

        public HttpRequest withQueryStringParameters​(Parameter... parameters)
        The query string parameters to match on as a varags Parameter objects where the values or keys of each parameter can be either a string or a regex (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Parameters:
        parameters - the varags Parameter objects where the values or keys of each parameter can be either a string or a regex

      • withQueryStringParameters

        public HttpRequest withQueryStringParameters​(Map<String,​List<String>> parameters)
        The query string parameters to match on as a Map<String, List<String>> where the values or keys of each parameter can be either a string or a regex (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Parameters:
        parameters - the Map<String, List<String>> object where the values or keys of each parameter can be either a string or a regex

      • withQueryStringParameter

        public HttpRequest withQueryStringParameter​(Parameter parameter)
        Adds one query string parameter to match on as a Parameter object where the parameter values list can be a list of strings or regular expressions (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Parameters:
        parameter - the Parameter object which can have a values list of strings or regular expressions

      • withQueryStringParameter

        public HttpRequest withQueryStringParameter​(String name,
                                            String... values)
        Adds one query string parameter to match which the values are plain strings or regular expressions (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Parameters:
        name - the parameter name
        values - the parameter values which can be a varags of strings or regular expressions

      • withSchemaQueryStringParameter

        public HttpRequest withSchemaQueryStringParameter​(String name,
                                                  String... values)
        Adds one query string parameter to match which the values are JSON schema i.e. "{ \"type\": \"string\", \"pattern\": \"^someV[a-z]{4}$\" }" (for more details of the supported JSON schema see https://json-schema.org)
        Parameters:
        name - the parameter name
        values - the parameter values which can be a varags of JSON schemas

      • withQueryStringParameter

        public HttpRequest withQueryStringParameter​(NottableString name,
                                            NottableString... values)
        Adds one query string parameter to match on or to not match on using the NottableString, each NottableString can either be a positive matching value, such as string("match"), or a value to not match on, such as not("do not match"), the string values passed to the NottableString can also be a plain string or a regex (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Parameters:
        name - the parameter name as a NottableString
        values - the parameter values which can be a varags of NottableStrings

      • getQueryStringParameterList

        public List<Parameter> getQueryStringParameterList()

      • hasQueryStringParameter

        public boolean hasQueryStringParameter​(String name,
                                       String value)

      • getFirstQueryStringParameter

        public String getFirstQueryStringParameter​(String name)

      • withBody

        public HttpRequest withBody​(String body)
        The exact string body to match on such as "this is an exact string body"
        Specified by:
        withBody in interface HttpMessage<HttpRequest,​Body>
        Parameters:
        body - the body on such as "this is an exact string body"

      • withBody

        public HttpRequest withBody​(String body,
                            Charset charset)
        The exact string body to match on such as "this is an exact string body"
        Specified by:
        withBody in interface HttpMessage<HttpRequest,​Body>
        Parameters:
        body - the body on such as "this is an exact string body"
        charset - character set the string will be encoded in

      • withBody

        public HttpRequest withBody​(Body body)
        The body match rules on such as using one of the Body subclasses as follows:

        exact string match: - exact("this is an exact string body");

        or

        - new StringBody("this is an exact string body")

        regular expression match: - regex("username[a-z]{4}");

        or

        - new RegexBody("username[a-z]{4}");

        json match: - json("{username: 'foo', password: 'bar'}");

        or

        - json("{username: 'foo', password: 'bar'}", MatchType.STRICT);

        or

        - new JsonBody("{username: 'foo', password: 'bar'}");

        json schema match: - jsonSchema("{type: 'object', properties: { 'username': { 'type': 'string' }, 'password': { 'type': 'string' } }, 'required': ['username', 'password']}");

        or

        - jsonSchemaFromResource("org/mockserver/model/loginSchema.json");

        or

        - new JsonSchemaBody("{type: 'object', properties: { 'username': { 'type': 'string' }, 'password': { 'type': 'string' } }, 'required': ['username', 'password']}");

        xpath match: - xpath("/element[key = 'some_key' and value = 'some_value']");

        or

        - new XPathBody("/element[key = 'some_key' and value = 'some_value']");

        body parameter match: - params( param("name_one", "value_one_one", "value_one_two") param("name_two", "value_two") );

        or

        - new ParameterBody( new Parameter("name_one", "value_one_one", "value_one_two") new Parameter("name_two", "value_two") );

        binary match: - binary(IOUtils.readFully(getClass().getClassLoader().getResourceAsStream("example.pdf"), 1024));

        or

        - new BinaryBody(IOUtils.readFully(getClass().getClassLoader().getResourceAsStream("example.pdf"), 1024));

        for more details of the supported regular expression syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html for more details of the supported json syntax see http://jsonassert.skyscreamer.org for more details of the supported json schema syntax see http://json-schema.org/ for more detail of XPath syntax see http://saxon.sourceforge.net/saxon6.5.3/expressions.html

        Specified by:
        withBody in interface HttpMessage<HttpRequest,​Body>
        Parameters:
        body - an instance of one of the Body subclasses including StringBody, ParameterBody or BinaryBody

      • getBodyAsJsonOrXmlString

        public String getBodyAsJsonOrXmlString()

      • withHeaders

        public HttpRequest withHeaders​(List<Header> headers)
        The headers to match on as a list of Header objects where the values or keys of each header can be either a string or a regex (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Specified by:
        withHeaders in interface HttpMessage<HttpRequest,​Body>
        Parameters:
        headers - the list of Header objects where the values or keys of each header can be either a string or a regex

      • withHeaders

        public HttpRequest withHeaders​(Header... headers)
        The headers to match on as a varags of Header objects where the values or keys of each header can be either a string or a regex (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Specified by:
        withHeaders in interface HttpMessage<HttpRequest,​Body>
        Parameters:
        headers - the varags of Header objects where the values or keys of each header can be either a string or a regex

      • withHeader

        public HttpRequest withHeader​(Header header)
        Adds one header to match on as a Header object where the header values list can be a list of strings or regular expressions (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Specified by:
        withHeader in interface HttpMessage<HttpRequest,​Body>
        Parameters:
        header - the Header object which can have a values list of strings or regular expressions

      • withHeader

        public HttpRequest withHeader​(String name,
                              String... values)
        Adds one header to match which can specified using plain strings or regular expressions (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Specified by:
        withHeader in interface HttpMessage<HttpRequest,​Body>
        Parameters:
        name - the header name
        values - the header values which can be a varags of strings or regular expressions

      • withSchemaHeader

        public HttpRequest withSchemaHeader​(String name,
                                    String... values)
        Adds one header to match which the values are JSON schema i.e. "{ \"type\": \"string\", \"pattern\": \"^someV[a-z]{4}$\" }" (for more details of the supported JSON schema see https://json-schema.org)
        Parameters:
        name - the header name
        values - the header values which can be a varags of JSON schemas

      • withHeader

        public HttpRequest withHeader​(NottableString name,
                              NottableString... values)
        Adds one header to match on or to not match on using the NottableString, each NottableString can either be a positive matching value, such as string("match"), or a value to not match on, such as not("do not match"), the string values passed to the NottableString can also be a plain string or a regex (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Specified by:
        withHeader in interface HttpMessage<HttpRequest,​Body>
        Parameters:
        name - the header name as a NottableString
        values - the header values which can be a varags of NottableStrings

      • replaceHeader

        public HttpRequest replaceHeader​(Header header)
        Adds one header to match on as a Header object where the header values list can be a list of strings or regular expressions (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Specified by:
        replaceHeader in interface HttpMessage<HttpRequest,​Body>
        Parameters:
        header - the Header object which can have a values list of strings or regular expressions

      • containsHeader

        public boolean containsHeader​(String name)
        Returns true if a header with the specified name has been added
        Specified by:
        containsHeader in interface HttpMessage<HttpRequest,​Body>
        Parameters:
        name - the header name
        Returns:
        true if a header has been added with that name otherwise false

      • containsHeader

        public boolean containsHeader​(String name,
                              String value)
        Returns true if a header with the specified name and value has been added
        Parameters:
        name - the header name
        value - the header value
        Returns:
        true if a header has been added with that name otherwise false

      • withCookies

        public HttpRequest withCookies​(List<Cookie> cookies)
        The cookies to match on as a list of Cookie objects where the values or keys of each cookie can be either a string or a regex (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Specified by:
        withCookies in interface HttpMessage<HttpRequest,​Body>
        Parameters:
        cookies - a list of Cookie objects

      • withCookies

        public HttpRequest withCookies​(Cookie... cookies)
        The cookies to match on as a varags Cookie objects where the values or keys of each cookie can be either a string or a regex (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Specified by:
        withCookies in interface HttpMessage<HttpRequest,​Body>
        Parameters:
        cookies - a varargs of Cookie objects

      • withCookie

        public HttpRequest withCookie​(Cookie cookie)
        Adds one cookie to match on as a Cookie object where the cookie values list can be a list of strings or regular expressions (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Specified by:
        withCookie in interface HttpMessage<HttpRequest,​Body>
        Parameters:
        cookie - a Cookie object

      • withCookie

        public HttpRequest withCookie​(String name,
                              String value)
        Adds one cookie to match on, which the value is plain strings or regular expressions (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Specified by:
        withCookie in interface HttpMessage<HttpRequest,​Body>
        Parameters:
        name - the cookies name
        value - the cookies value

      • withSchemaCookie

        public HttpRequest withSchemaCookie​(String name,
                                    String value)
        Adds one cookie to match on, which the value the values is JSON schema i.e. "{ \"type\": \"string\", \"pattern\": \"^someV[a-z]{4}$\" }" (for more details of the supported JSON schema see https://json-schema.org)
        Parameters:
        name - the cookies name
        value - the cookies value as JSON schema

      • withCookie

        public HttpRequest withCookie​(NottableString name,
                              NottableString value)
        Adds one cookie to match on or to not match on using the NottableString, each NottableString can either be a positive matching value, such as string("match"), or a value to not match on, such as not("do not match"), the string values passed to the NottableString can be a plain string or a regex (for more details of the supported regex syntax see http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
        Specified by:
        withCookie in interface HttpMessage<HttpRequest,​Body>
        Parameters:
        name - the cookies name
        value - the cookies value

      • socketAddressFromHostHeader

        public InetSocketAddress socketAddressFromHostHeader()