Package net.jadler

Interface RequestMatching<T extends RequestMatching<T>>

  • Type Parameters:
    T - type (either class or interface) of the implementation. This type will be returned by all methods introduced by this interface so fluid request matching is possible.
    All Known Subinterfaces:
    RequestStubbing
    All Known Implementing Classes:
    AbstractRequestMatching, Stubbing, Verifying
    public interface RequestMatching<T extends RequestMatching<T>>
    This interface introduces methods for a fluent request matching. Classes implementing this interface usually collect request predicates using these methods.

    • Method Detail

      • that

        T that​(org.hamcrest.Matcher<? super Request> predicate)
        Adds a request predicate to this request matching.
        Parameters:
        predicate - request predicate to be added to this request matching (cannot be null)
        Returns:
        this ongoing request matching

      • havingMethodEqualTo

        T havingMethodEqualTo​(String method)
        Adds a request method predicate. The request method must be equal (case insensitive) to the given value.
        Parameters:
        method - expected http method of the incoming http request
        Returns:
        this ongoing request matching

      • havingMethod

        T havingMethod​(org.hamcrest.Matcher<? super String> predicate)
        Adds a request method predicate.
        Parameters:
        predicate - request method predicate (cannot be null)
        Returns:
        this ongoing request matching

      • havingBodyEqualTo

        T havingBodyEqualTo​(String requestBody)
        Adds a request body predicate. The request body must be equal to the given value. An empty request body is represented by an empty string (not a null value) and therefore it can be matched by following invocation: havingBodyEqualTo("").
        Parameters:
        requestBody - expected body of the incoming http request
        Returns:
        this ongoing request matching

      • havingBody

        T havingBody​(org.hamcrest.Matcher<? super String> predicate)
        Adds a request body predicate. An empty request body is represented by an empty string (not a null value) and therefore it can be matched for example by havingBody(equalTo("")).
        Parameters:
        predicate - request body predicate (cannot be null)
        Returns:
        this ongoing request matching

      • havingRawBodyEqualTo

        T havingRawBodyEqualTo​(byte[] requestBody)
        Adds a request body predicate. The request body must be equal to the given value. An empty request body is represented as an empty array (not a null value) and therefore it can be matched by havingRawBodyEqualTo(new byte[0]).
        Parameters:
        requestBody - expected body of the incoming http request
        Returns:
        this ongoing request matching

      • havingPathEqualTo

        T havingPathEqualTo​(String path)
        Adds a request path predicate. The request path must be equal to the given value. A root path can be matched by havingPathEqualTo("/"). Please note the path value doesn't contain a query string portion and is percent-encoded.
        Parameters:
        path - expected path of the incoming http request
        Returns:
        this ongoing request matching

      • havingPath

        T havingPath​(org.hamcrest.Matcher<? super String> predicate)
        Adds a request path predicate. A root path can be matched by havingPath(equalTo("/")) for example. Please note the path value doesn't contain a query string portion and is percent-encoded.
        Parameters:
        predicate - request path predicate (cannot be null)
        Returns:
        this ongoing request matching

      • havingQueryStringEqualTo

        T havingQueryStringEqualTo​(String queryString)
        Adds a query string predicate. The query string must be equal to the given value. Examples:
        • havingQueryStringEqualTo(null) matches a request without a query string (no ? character in URI, http://localhost/a/b).
        • havingQueryStringEqualTo("") matches a request with an empty query string (http://localhost/?)
        • havingQueryStringEqualTo("a=b") matches a request with the exact query string (http://localhost/?a=b)
        Please note the query string value is percent-encoded.
        Parameters:
        queryString - expected query string of the incoming http request
        Returns:
        this ongoing request matching

      • havingQueryString

        T havingQueryString​(org.hamcrest.Matcher<? super String> predicate)
        Adds a query string predicate. Examples:
        • havingQueryString(nullValue()) matches a request without a query string (no ? character in URI, http://localhost/a/b).
        • havingQueryString(isEmptyString()) matches a request with an empty query string (http://localhost/?)
        • havingQueryString(equalTo("a=b")) matches a request with the exact query string (http://localhost/?a=b)

        Please note the query string is percent-encoded.

        Parameters:
        predicate - query string predicate (cannot be null)
        Returns:
        this ongoing request matching

      • havingParameterEqualTo

        T havingParameterEqualTo​(String name,
                         String value)

        Adds a request parameter predicate. The given http parameter must be present in the incoming request and at least one of its values must be equal to the given value. Both the name and the value are percent-encoded.

        Parameters are key=value pairs contained in the query string or in the request body (the content-type header must be application/x-www-form-urlencoded in this case)

        Parameters:
        name - case sensitive parameter name (cannot be empty)
        value - expected parameter value (cannot be null)
        Returns:
        this ongoing request matching

      • havingParameter

        T havingParameter​(String name,
                  org.hamcrest.Matcher<? super List<String>> predicate)

        Adds a request parameter predicate. Parameters are key=value pairs contained in the query string or in the request body (the content-type header must be application/x-www-form-urlencoded in this case)

        Since a request parameter can have more than one value, the predicate is on a list of values. Examples:

        • havingParameter("unknown-param", nullValue()) matches a request without an unknown-param
        • havingParameter("existing-param", not(empty())) matches a request which contains at least one existing-param
        • havingParameter("existing-param", hasItem("value")) matches a request which contains at least one existing-param with the value value
        Parameters:
        name - case sensitive parameter name (cannot be empty)
        predicate - parameter predicate (cannot be null)
        Returns:
        this ongoing request matching

      • havingParameter

        T havingParameter​(String name)

        Adds a request parameter existence predicate. The given http parameter must be present in the request body.

        Parameters are key=value pairs contained in the query string or in the request body (the content-type header must be application/x-www-form-urlencoded in this case)

        Parameters:
        name - case sensitive parameter name (cannot be empty)
        Returns:
        this ongoing request matching

      • havingParameters

        T havingParameters​(String... names)

        Adds a request parameters existence predicate. All of the given http parameters must be present in the request body.

        Parameters are key=value pairs contained in the query string or in the request body (the content-type header must be application/x-www-form-urlencoded in this case)

        Parameters:
        names - case sensitive parameter names
        Returns:
        this ongoing request matching

      • havingHeaderEqualTo

        T havingHeaderEqualTo​(String name,
                      String value)
        Adds a request header predicate. The given http header must be present in the request body and at least one of its values must be equal to the given value.
        Parameters:
        name - case insensitive header name (cannot be empty)
        value - expected header value (cannot be null)
        Returns:
        this ongoing request matching

      • havingHeader

        T havingHeader​(String name,
               org.hamcrest.Matcher<? super List<String>> predicate)
        Adds a request header predicate. Since a request header can have more than one value, the predicate is on a list of values. Examples:
        • havingHeader("unknown-header", nullValue()) matches a request without an unknown-header
        • havingHeader("existing-header", not(empty())) matches a request which contains at least one existing-header
        • havingHeader("existing-header", hasItem("value")) matches a request which contains at least one existing-header with the value value
        Parameters:
        name - case insensitive header name (cannot be empty)
        predicate - header predicate (cannot be null)
        Returns:
        this ongoing request matching

      • havingHeader

        T havingHeader​(String name)
        Adds a request header existence predicate. The given http header must be present in the request body
        Parameters:
        name - case insensitive header name (cannot be empty)
        Returns:
        this ongoing request matching

      • havingHeaders

        T havingHeaders​(String... names)
        Adds a request headers existence predicate. All of the given http headers must be present in the request body.
        Parameters:
        names - case insensitive headers names
        Returns:
        this ongoing request matching