MockServerClient (MockServer Java Client 5.15.0 API)

java.lang.Object
- org.mockserver.client.MockServerClient

All Implemented Interfaces:

Closeable, AutoCloseable, Stoppable
```
public class MockServerClient
extends Object
implements Stoppable
```
Author:

jamesdbloom

Field Summary

Fields
Modifier and Type Field and Description

protected CompletableFuture<Integer> portFuture

Fields
Modifier and Type	Field and Description
`protected CompletableFuture<Integer>`	`portFuture`

Constructor Summary

Constructors
Constructor and Description
`MockServerClient(ClientConfiguration configuration, CompletableFuture<Integer> portFuture)` Start the client communicating to a MockServer on localhost at the port specified with the Future
`MockServerClient(ClientConfiguration configuration, String host, int port)` Start the client communicating to a MockServer at the specified host and port for example:
`MockServerClient(ClientConfiguration configuration, String host, int port, String contextPath)` Start the client communicating to a MockServer at the specified host and port and contextPath for example:
`MockServerClient(Configuration configuration, CompletableFuture<Integer> portFuture)` Start the client communicating to a MockServer on localhost at the port specified with the Future
`MockServerClient(Configuration configuration, String host, int port)` Start the client communicating to a MockServer at the specified host and port for example:
`MockServerClient(Configuration configuration, String host, int port, String contextPath)` Start the client communicating to a MockServer at the specified host and port and contextPath for example:
`MockServerClient(String host, int port)` Start the client communicating to a MockServer at the specified host and port for example:
`MockServerClient(String host, int port, String contextPath)` Start the client communicating to a MockServer at the specified host and port and contextPath for example:

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`List<Integer>`	`bind(Integer... ports)` Bind new ports to listen on
`MockServerClient`	`clear(ExpectationId expectationId)` Clear all expectations and logs that match the expectation id
`MockServerClient`	`clear(ExpectationId expectationId, ClearType type)` Clear expectations, logs or both that match the expectation id
`MockServerClient`	`clear(RequestDefinition requestDefinition)` Clear all expectations and logs that match the request matcher
`MockServerClient`	`clear(RequestDefinition requestDefinition, ClearType type)` Clear expectations, logs or both that match the request matcher
`MockServerClient`	`clear(String expectationId)` Clear all expectations and logs that match the expectation id
`MockServerClient`	`clear(String expectationId, ClearType type)` Clear expectations, logs or both that match the expectation id
`void`	`close()`
`String`	`contextPath()`
`Integer`	`getPort()`
`boolean`	`hasStarted()` Returns whether MockServer has started, if called after MockServer has been stopped this method will block for 5 seconds while confirming MockServer is not starting
`boolean`	`hasStarted(int attempts, long timeout, TimeUnit timeUnit)` Returns whether server MockServer has started, by polling the MockServer a configurable amount of times
`boolean`	`hasStopped()` Returns whether MockServer has stopped, if called too quickly after starting MockServer this may return false because MockServer has not yet started, to ensure MockServer has started use hasStarted()
`boolean`	`hasStopped(int attempts, long timeout, TimeUnit timeUnit)` Returns whether server MockServer has stopped, by polling the MockServer a configurable amount of times.
`boolean`	`isRunning()` Deprecated. use hasStopped() or hasStarted() instead
`boolean`	`isRunning(int attempts, long timeout, TimeUnit timeUnit)` Deprecated. use hasStopped() or hasStarted() instead
`boolean`	`isSecure()`
`MockServerClient`	`openUI()` Launch UI and wait the default period to allow the UI to launch and start collecting logs, this ensures that the log are visible in the UI even if MockServer is shutdown by a test shutdown function, such as After, AfterClass, AfterAll, etc
`MockServerClient`	`openUI(TimeUnit timeUnit, long pause)` Launch UI and wait a specified period to allow the UI to launch and start collecting logs, this ensures that the log are visible in the UI even if MockServer is shutdown by a test shutdown function, such as After, AfterClass, AfterAll, etc
`InetSocketAddress`	`remoteAddress()`
`MockServerClient`	`reset()` Reset MockServer by clearing all expectations
`Expectation[]`	`retrieveActiveExpectations(RequestDefinition requestDefinition)` Retrieve the active expectations match the httpRequest parameter, use null for the parameter to retrieve all expectations
`String`	`retrieveActiveExpectations(RequestDefinition requestDefinition, Format format)` Retrieve the active expectations match the httpRequest parameter, use null for the parameter to retrieve all expectations
`String`	`retrieveLogMessages(RequestDefinition requestDefinition)` Retrieve the logs associated to a specific requests, this shows all logs for expectation matching, verification, clearing, etc
`String[]`	`retrieveLogMessagesArray(RequestDefinition requestDefinition)` Retrieve the logs associated to a specific requests, this shows all logs for expectation matching, verification, clearing, etc
`Expectation[]`	`retrieveRecordedExpectations(RequestDefinition requestDefinition)` Retrieve the request-response combinations that have been recorded as a list of expectations, only those that match the httpRequest parameter are returned, use null to retrieve all requests
`String`	`retrieveRecordedExpectations(RequestDefinition requestDefinition, Format format)` Retrieve the request-response combinations that have been recorded as a list of expectations, only those that match the httpRequest parameter are returned, use null to retrieve all requests
`HttpRequest[]`	`retrieveRecordedRequests(RequestDefinition requestDefinition)` Retrieve the recorded requests that match the httpRequest parameter, use null for the parameter to retrieve all requests
`String`	`retrieveRecordedRequests(RequestDefinition requestDefinition, Format format)` Retrieve the recorded requests that match the httpRequest parameter, use null for the parameter to retrieve all requests
`LogEventRequestAndResponse[]`	`retrieveRecordedRequestsAndResponses(RequestDefinition requestDefinition)` Retrieve the recorded requests and responses that match the httpRequest parameter, use null for the parameter to retrieve all requests and responses
`String`	`retrieveRecordedRequestsAndResponses(RequestDefinition requestDefinition, Format format)` Retrieve the recorded requests that match the httpRequest parameter, use null for the parameter to retrieve all requests
`Expectation[]`	`sendExpectation(Expectation... expectations)` Deprecated. this is deprecated due to unclear naming, use method upsert(Expectation... expectations) instead
`MockServerClient`	`setProxyConfiguration(ProxyConfiguration proxyConfiguration)` Deprecated. use withProxyConfiguration which is more consistent with MockServer API style
`MockServerClient`	`setRequestOverride(HttpRequest requestOverride)` Deprecated. use withRequestOverride which is more consistent with MockServer API style
`void`	`stop()` Stop MockServer gracefully (only support for Netty version, not supported for WAR version)
`CompletableFuture<MockServerClient>`	`stop(boolean ignoreFailure)` Stop MockServer gracefully (only support for Netty version, not supported for WAR version)
`Future<MockServerClient>`	`stopAsync()` Stop MockServer gracefully (only support for Netty version, not supported for WAR version)
`Expectation[]`	`upsert(Expectation... expectations)` Specify one or more expectations to be create, or updated (if the id matches).
`Expectation[]`	`upsert(OpenAPIExpectation... openAPIExpectations)` Specify OpenAPI and operations and responses to create matchers and example responses
`MockServerClient`	`verify(ExpectationId... expectationIds)` Verify a list of requests have been sent in the order specified for example:
`MockServerClient`	`verify(ExpectationId expectationId, VerificationTimes times)` Verify a request has been sent for example:
`MockServerClient`	`verify(ExpectationId expectationId, VerificationTimes times, Integer maximumNumberOfRequestToReturnInVerificationFailure)` Verify a request has been sent for example:
`MockServerClient`	`verify(Integer maximumNumberOfRequestToReturnInVerificationFailure, ExpectationId... expectationIds)` Verify a list of requests have been sent in the order specified for example:
`MockServerClient`	`verify(Integer maximumNumberOfRequestToReturnInVerificationFailure, RequestDefinition... requestDefinitions)` Verify a list of requests have been sent in the order specified for example:
`MockServerClient`	`verify(RequestDefinition... requestDefinitions)` Verify a list of requests have been sent in the order specified for example:
`MockServerClient`	`verify(RequestDefinition requestDefinition, VerificationTimes times)` Verify a request has been sent for example:
`MockServerClient`	`verify(RequestDefinition requestDefinition, VerificationTimes times, Integer maximumNumberOfRequestToReturnInVerificationFailure)` Verify a request has been sent for example:
`MockServerClient`	`verify(String... expectationIds)` Verify a list of requests have been sent in the order specified for example:
`MockServerClient`	`verify(String expectationId, VerificationTimes times)` Verify a request has been sent for example:
`MockServerClient`	`verifyZeroInteractions()` Verify no requests have been sent.
`ForwardChainExpectation`	`when(RequestDefinition requestDefinition)` Specify an unlimited expectation that will respond regardless of the number of matching http for example:
`ForwardChainExpectation`	`when(RequestDefinition requestDefinition, Times times)` Specify a limited expectation that will respond a specified number of times when the http is matched
`ForwardChainExpectation`	`when(RequestDefinition requestDefinition, Times times, TimeToLive timeToLive)` Specify a limited expectation that will respond a specified number of times when the http is matched
`ForwardChainExpectation`	`when(RequestDefinition requestDefinition, Times times, TimeToLive timeToLive, Integer priority)` Specify a limited expectation that will respond a specified number of times when the http is matched and will be matched according to priority as follows:
`MockServerClient`	`withControlPlaneJWT(String controlPlaneJWT)` Specify JWT to use for control plane authorisation
`MockServerClient`	`withControlPlaneJWT(Supplier<String> controlPlaneJWTSupplier)` Specify JWT supplier to use for control plane authorisation
`MockServerClient`	`withProxyConfiguration(ProxyConfiguration proxyConfiguration)` Configure communication to MockServer to go via a proxy
`MockServerClient`	`withRequestOverride(HttpRequest requestOverride)`
`MockServerClient`	`withSecure(boolean secure)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - portFuture
```
protected CompletableFuture<Integer> portFuture
```
- Constructor Detail
  - MockServerClient
```
public MockServerClient(Configuration configuration,
                        CompletableFuture<Integer> portFuture)
```
    Start the client communicating to a MockServer on localhost at the port specified with the Future
    
    Parameters:
    
    portFuture - the port for the MockServer to communicate with
  - MockServerClient
```
public MockServerClient(ClientConfiguration configuration,
                        CompletableFuture<Integer> portFuture)
```
    Start the client communicating to a MockServer on localhost at the port specified with the Future
    
    Parameters:
    
    portFuture - the port for the MockServer to communicate with
  - MockServerClient
```
public MockServerClient(String host,
                        int port)
```
    Start the client communicating to a MockServer at the specified host and port for example:
    MockServerClient mockServerClient = new MockServerClient("localhost", 1080);
    
    Parameters:
    
    host - the host for the MockServer to communicate with
    
    port - the port for the MockServer to communicate with
  - MockServerClient
```
public MockServerClient(Configuration configuration,
                        String host,
                        int port)
```
    Start the client communicating to a MockServer at the specified host and port for example:
    MockServerClient mockServerClient = new MockServerClient("localhost", 1080);
    
    Parameters:
    
    host - the host for the MockServer to communicate with
    
    port - the port for the MockServer to communicate with
  - MockServerClient
```
public MockServerClient(ClientConfiguration configuration,
                        String host,
                        int port)
```
    Start the client communicating to a MockServer at the specified host and port for example:
    MockServerClient mockServerClient = new MockServerClient("localhost", 1080);
    
    Parameters:
    
    host - the host for the MockServer to communicate with
    
    port - the port for the MockServer to communicate with
  - MockServerClient
```
public MockServerClient(String host,
                        int port,
                        String contextPath)
```
    Start the client communicating to a MockServer at the specified host and port and contextPath for example:
    MockServerClient mockServerClient = new MockServerClient("localhost", 1080, "/mockserver");
    
    Parameters:
    
    host - the host for the MockServer to communicate with
    
    port - the port for the MockServer to communicate with
    
    contextPath - the context path that the MockServer war is deployed to
  - MockServerClient
```
public MockServerClient(Configuration configuration,
                        String host,
                        int port,
                        String contextPath)
```
    Start the client communicating to a MockServer at the specified host and port and contextPath for example:
    MockServerClient mockServerClient = new MockServerClient("localhost", 1080, "/mockserver");
    
    Parameters:
    
    host - the host for the MockServer to communicate with
    
    port - the port for the MockServer to communicate with
    
    contextPath - the context path that the MockServer war is deployed to
  - MockServerClient
```
public MockServerClient(ClientConfiguration configuration,
                        String host,
                        int port,
                        String contextPath)
```
    Start the client communicating to a MockServer at the specified host and port and contextPath for example:
    MockServerClient mockServerClient = new MockServerClient("localhost", 1080, "/mockserver");
    
    Parameters:
    
    host - the host for the MockServer to communicate with
    
    port - the port for the MockServer to communicate with
    
    contextPath - the context path that the MockServer war is deployed to
- Method Detail
  - setProxyConfiguration
```
@Deprecated
public MockServerClient setProxyConfiguration(ProxyConfiguration proxyConfiguration)
```
    Deprecated. use withProxyConfiguration which is more consistent with MockServer API style
  - withProxyConfiguration
```
public MockServerClient withProxyConfiguration(ProxyConfiguration proxyConfiguration)
```
    Configure communication to MockServer to go via a proxy
  - withControlPlaneJWT
```
public MockServerClient withControlPlaneJWT(String controlPlaneJWT)
```
    Specify JWT to use for control plane authorisation
  - withControlPlaneJWT
```
public MockServerClient withControlPlaneJWT(Supplier<String> controlPlaneJWTSupplier)
```
    Specify JWT supplier to use for control plane authorisation
  - setRequestOverride
```
@Deprecated
public MockServerClient setRequestOverride(HttpRequest requestOverride)
```
    Deprecated. use withRequestOverride which is more consistent with MockServer API style
  - withRequestOverride
```
public MockServerClient withRequestOverride(HttpRequest requestOverride)
```
  - isSecure
```
public boolean isSecure()
```
  - withSecure
```
public MockServerClient withSecure(boolean secure)
```
  - remoteAddress
```
public InetSocketAddress remoteAddress()
```
  - contextPath
```
public String contextPath()
```
  - getPort
```
public Integer getPort()
```
  - openUI
```
public MockServerClient openUI()
```
    Launch UI and wait the default period to allow the UI to launch and start collecting logs, this ensures that the log are visible in the UI even if MockServer is shutdown by a test shutdown function, such as After, AfterClass, AfterAll, etc
  - openUI
```
public MockServerClient openUI(TimeUnit timeUnit,
                               long pause)
```
    Launch UI and wait a specified period to allow the UI to launch and start collecting logs, this ensures that the log are visible in the UI even if MockServer is shutdown by a test shutdown function, such as After, AfterClass, AfterAll, etc
    
    Parameters:
    
    timeUnit - TimeUnit the time unit, for example TimeUnit.SECONDS
    
    pause - the number of time units to delay before the function returns to ensure the UI is receiving logs
  - isRunning
```
@Deprecated
public boolean isRunning()
```
    Deprecated. use hasStopped() or hasStarted() instead
    
    Returns whether MockServer is running, if called too quickly after starting MockServer this may return false because MockServer has not yet started, to ensure MockServer has started use hasStarted()
  - isRunning
```
@Deprecated
public boolean isRunning(int attempts,
                                     long timeout,
                                     TimeUnit timeUnit)
```
    Deprecated. use hasStopped() or hasStarted() instead
    
    Returns whether server MockServer is running, by polling the MockServer a configurable amount of times. If called too quickly after starting MockServer this may return false because MockServer has not yet started, to ensure MockServer has started use hasStarted()
  - hasStopped
```
public boolean hasStopped()
```
    Returns whether MockServer has stopped, if called too quickly after starting MockServer this may return false because MockServer has not yet started, to ensure MockServer has started use hasStarted()
  - hasStopped
```
public boolean hasStopped(int attempts,
                          long timeout,
                          TimeUnit timeUnit)
```
    Returns whether server MockServer has stopped, by polling the MockServer a configurable amount of times. If called too quickly after starting MockServer this may return false because MockServer has not yet started, to ensure MockServer has started use hasStarted()
  - hasStarted
```
public boolean hasStarted()
```
    Returns whether MockServer has started, if called after MockServer has been stopped this method will block for 5 seconds while confirming MockServer is not starting
  - hasStarted
```
public boolean hasStarted(int attempts,
                          long timeout,
                          TimeUnit timeUnit)
```
    Returns whether server MockServer has started, by polling the MockServer a configurable amount of times
  - bind
```
public List<Integer> bind(Integer... ports)
```
    Bind new ports to listen on
  - stopAsync
```
public Future<MockServerClient> stopAsync()
```
    Stop MockServer gracefully (only support for Netty version, not supported for WAR version)
  - stop
```
public void stop()
```
    Stop MockServer gracefully (only support for Netty version, not supported for WAR version)
    
    Specified by:
    
    stop in interface Stoppable
  - stop
```
public CompletableFuture<MockServerClient> stop(boolean ignoreFailure)
```
    Stop MockServer gracefully (only support for Netty version, not supported for WAR version)
  - close
```
public void close()
```
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
  - reset
```
public MockServerClient reset()
```
    Reset MockServer by clearing all expectations
  - clear
```
public MockServerClient clear(RequestDefinition requestDefinition)
```
    Clear all expectations and logs that match the request matcher
    
    Parameters:
    
    requestDefinition - the http request that is matched against when deciding whether to clear each expectation if null all expectations are cleared
  - clear
```
public MockServerClient clear(String expectationId)
```
    Clear all expectations and logs that match the expectation id
    
    Parameters:
    
    expectationId - the expectation id that is used to clear expectations and logs
  - clear
```
public MockServerClient clear(ExpectationId expectationId)
```
    Clear all expectations and logs that match the expectation id
    
    Parameters:
    
    expectationId - the expectation id that is used to clear expectations and logs
  - clear
```
public MockServerClient clear(RequestDefinition requestDefinition,
                              ClearType type)
```
    Clear expectations, logs or both that match the request matcher
    
    Parameters:
    
    requestDefinition - the http request that is matched against when deciding whether to clear each expectation if null all expectations are cleared
    
    type - the type to clear, EXPECTATION, LOG or BOTH
  - clear
```
public MockServerClient clear(String expectationId,
                              ClearType type)
```
    Clear expectations, logs or both that match the expectation id
    
    Parameters:
    
    expectationId - the expectation id that is used to clear expectations and logs
    
    type - the type to clear, EXPECTATION, LOG or BOTH
  - clear
```
public MockServerClient clear(ExpectationId expectationId,
                              ClearType type)
```
    Clear expectations, logs or both that match the expectation id
    
    Parameters:
    
    expectationId - the expectation id that is used to clear expectations and logs
    
    type - the type to clear, EXPECTATION, LOG or BOTH
  - verify
```
public MockServerClient verify(RequestDefinition... requestDefinitions)
                        throws AssertionError
```
    Verify a list of requests have been sent in the order specified for example:
```
 mockServerClient
  .verify(
      request()
          .withPath("/first_request")
          .withBody("some_request_body"),
      request()
          .withPath("/second_request")
          .withBody("some_request_body")
  );
 
```
    Parameters:
    
    requestDefinitions - the http requests that must be matched for this verification to pass
    
    Throws:
    
    AssertionError - if the request has not been found
  - verify
```
public MockServerClient verify(Integer maximumNumberOfRequestToReturnInVerificationFailure,
                               RequestDefinition... requestDefinitions)
                        throws AssertionError
```
    Verify a list of requests have been sent in the order specified for example:
```
 mockServerClient
  .verify(
      request()
          .withPath("/first_request")
          .withBody("some_request_body"),
      request()
          .withPath("/second_request")
          .withBody("some_request_body")
  );
 
```
    Parameters:
    
    maximumNumberOfRequestToReturnInVerificationFailure - the maximum number requests return in the error response when the verification fails
    
    requestDefinitions - the http requests that must be matched for this verification to pass
    
    Throws:
    
    AssertionError - if the request has not been found
  - verify
```
public MockServerClient verify(String... expectationIds)
                        throws AssertionError
```
    Verify a list of requests have been sent in the order specified for example:
```
 mockServerClient
  .verify(
      request()
          .withPath("/first_request")
          .withBody("some_request_body"),
      request()
          .withPath("/second_request")
          .withBody("some_request_body")
  );
 
```
    Parameters:
    
    expectationIds - the http requests that must be matched for this verification to pass
    
    Throws:
    
    AssertionError - if the request has not been found
  - verify
```
public MockServerClient verify(ExpectationId... expectationIds)
                        throws AssertionError
```
    Verify a list of requests have been sent in the order specified for example:
```
 mockServerClient
  .verify(
      request()
          .withPath("/first_request")
          .withBody("some_request_body"),
      request()
          .withPath("/second_request")
          .withBody("some_request_body")
  );
 
```
    Parameters:
    
    expectationIds - the http requests that must be matched for this verification to pass
    
    Throws:
    
    AssertionError - if the request has not been found
  - verify
```
public MockServerClient verify(Integer maximumNumberOfRequestToReturnInVerificationFailure,
                               ExpectationId... expectationIds)
                        throws AssertionError
```
    Verify a list of requests have been sent in the order specified for example:
```
 mockServerClient
  .verify(
      request()
          .withPath("/first_request")
          .withBody("some_request_body"),
      request()
          .withPath("/second_request")
          .withBody("some_request_body")
  );
 
```
    Parameters:
    
    maximumNumberOfRequestToReturnInVerificationFailure - the maximum number requests return in the error response when the verification fails
    
    expectationIds - the http requests that must be matched for this verification to pass
    
    Throws:
    
    AssertionError - if the request has not been found
  - verify
```
public MockServerClient verify(RequestDefinition requestDefinition,
                               VerificationTimes times)
                        throws AssertionError
```
    Verify a request has been sent for example:
```
 mockServerClient
  .verify(
      request()
          .withPath("/some_path")
          .withBody("some_request_body"),
      VerificationTimes.exactly(3)
  );
 
```
    VerificationTimes supports multiple static factory methods:
    once() - verify the request was only received once exactly(n) - verify the request was only received exactly n times atLeast(n) - verify the request was only received at least n times
    Parameters:
    
    requestDefinition - the http request that must be matched for this verification to pass
    
    times - the number of times this request must be matched
    
    Throws:
    
    AssertionError - if the request has not been found
  - verify
```
public MockServerClient verify(RequestDefinition requestDefinition,
                               VerificationTimes times,
                               Integer maximumNumberOfRequestToReturnInVerificationFailure)
                        throws AssertionError
```
    Verify a request has been sent for example:
```
 mockServerClient
  .verify(
      request()
          .withPath("/some_path")
          .withBody("some_request_body"),
      VerificationTimes.exactly(3)
  );
 
```
    VerificationTimes supports multiple static factory methods:
    once() - verify the request was only received once exactly(n) - verify the request was only received exactly n times atLeast(n) - verify the request was only received at least n times
    Parameters:
    
    requestDefinition - the http request that must be matched for this verification to pass
    
    times - the number of times this request must be matched
    
    maximumNumberOfRequestToReturnInVerificationFailure - the maximum number requests return in the error response when the verification fails
    
    Throws:
    
    AssertionError - if the request has not been found
  - verify
```
public MockServerClient verify(String expectationId,
                               VerificationTimes times)
                        throws AssertionError
```
    Verify a request has been sent for example:
```
 mockServerClient
  .verify(
      request()
          .withPath("/some_path")
          .withBody("some_request_body"),
      VerificationTimes.exactly(3)
  );
 
```
    VerificationTimes supports multiple static factory methods:
    once() - verify the request was only received once exactly(n) - verify the request was only received exactly n times atLeast(n) - verify the request was only received at least n times
    Parameters:
    
    expectationId - the http request that must be matched for this verification to pass
    
    times - the number of times this request must be matched
    
    Throws:
    
    AssertionError - if the request has not been found
  - verify
```
public MockServerClient verify(ExpectationId expectationId,
                               VerificationTimes times)
                        throws AssertionError
```
    Verify a request has been sent for example:
```
 mockServerClient
  .verify(
      request()
          .withPath("/some_path")
          .withBody("some_request_body"),
      VerificationTimes.exactly(3)
  );
 
```
    VerificationTimes supports multiple static factory methods:
    once() - verify the request was only received once exactly(n) - verify the request was only received exactly n times atLeast(n) - verify the request was only received at least n times
    Parameters:
    
    expectationId - the http request that must be matched for this verification to pass
    
    times - the number of times this request must be matched
    
    Throws:
    
    AssertionError - if the request has not been found
  - verify
```
public MockServerClient verify(ExpectationId expectationId,
                               VerificationTimes times,
                               Integer maximumNumberOfRequestToReturnInVerificationFailure)
                        throws AssertionError
```
    Verify a request has been sent for example:
```
 mockServerClient
  .verify(
      request()
          .withPath("/some_path")
          .withBody("some_request_body"),
      VerificationTimes.exactly(3)
  );
 
```
    VerificationTimes supports multiple static factory methods:
    once() - verify the request was only received once exactly(n) - verify the request was only received exactly n times atLeast(n) - verify the request was only received at least n times
    Parameters:
    
    expectationId - the http request that must be matched for this verification to pass
    
    times - the number of times this request must be matched
    
    maximumNumberOfRequestToReturnInVerificationFailure - the maximum number requests return in the error response when the verification fails
    
    Throws:
    
    AssertionError - if the request has not been found
  - verifyZeroInteractions
```
public MockServerClient verifyZeroInteractions()
                                        throws AssertionError
```
    Verify no requests have been sent.
    
    Throws:
    
    AssertionError - if any request has been found
  - retrieveRecordedRequests
```
public HttpRequest[] retrieveRecordedRequests(RequestDefinition requestDefinition)
```
    Retrieve the recorded requests that match the httpRequest parameter, use null for the parameter to retrieve all requests
    
    Parameters:
    
    requestDefinition - the http request that is matched against when deciding whether to return each request, use null for the parameter to retrieve for all requests
    
    Returns:
    
    an array of all requests that have been recorded by the MockServer in the order they have been received and including duplicates where the same request has been received multiple times
  - retrieveRecordedRequests
```
public String retrieveRecordedRequests(RequestDefinition requestDefinition,
                                       Format format)
```
    Retrieve the recorded requests that match the httpRequest parameter, use null for the parameter to retrieve all requests
    
    Parameters:
    
    requestDefinition - the http request that is matched against when deciding whether to return each request, use null for the parameter to retrieve for all requests
    
    format - the format to retrieve the expectations, either JAVA or JSON
    
    Returns:
    
    an array of all requests that have been recorded by the MockServer in the order they have been received and including duplicates where the same request has been received multiple times
  - retrieveRecordedRequestsAndResponses
```
public LogEventRequestAndResponse[] retrieveRecordedRequestsAndResponses(RequestDefinition requestDefinition)
```
    Retrieve the recorded requests and responses that match the httpRequest parameter, use null for the parameter to retrieve all requests and responses
    
    Parameters:
    
    requestDefinition - the http request that is matched against when deciding whether to return each request (and its corresponding response), use null for the parameter to retrieve for all requests
    
    Returns:
    
    an array of all requests and responses that have been recorded by the MockServer in the order they have been received and including duplicates where the same request has been received multiple times
  - retrieveRecordedRequestsAndResponses
```
public String retrieveRecordedRequestsAndResponses(RequestDefinition requestDefinition,
                                                   Format format)
```
    Retrieve the recorded requests that match the httpRequest parameter, use null for the parameter to retrieve all requests
    
    Parameters:
    
    requestDefinition - the http request that is matched against when deciding whether to return each request, use null for the parameter to retrieve for all requests
    
    format - the format to retrieve the expectations, either JAVA or JSON
    
    Returns:
    
    an array of all requests that have been recorded by the MockServer in the order they have been received and including duplicates where the same request has been received multiple times
  - retrieveRecordedExpectations
```
public Expectation[] retrieveRecordedExpectations(RequestDefinition requestDefinition)
```
    Retrieve the request-response combinations that have been recorded as a list of expectations, only those that match the httpRequest parameter are returned, use null to retrieve all requests
    
    Parameters:
    
    requestDefinition - the http request that is matched against when deciding whether to return each request, use null for the parameter to retrieve for all requests
    
    Returns:
    
    an array of all expectations that have been recorded by the MockServer in the order they have been received and including duplicates where the same request has been received multiple times
  - retrieveRecordedExpectations
```
public String retrieveRecordedExpectations(RequestDefinition requestDefinition,
                                           Format format)
```
    Retrieve the request-response combinations that have been recorded as a list of expectations, only those that match the httpRequest parameter are returned, use null to retrieve all requests
    
    Parameters:
    
    requestDefinition - the http request that is matched against when deciding whether to return each request, use null for the parameter to retrieve for all requests
    
    format - the format to retrieve the expectations, either JAVA or JSON
    
    Returns:
    
    an array of all expectations that have been recorded by the MockServer in the order they have been received and including duplicates where the same request has been received multiple times
  - retrieveLogMessages
```
public String retrieveLogMessages(RequestDefinition requestDefinition)
```
    Retrieve the logs associated to a specific requests, this shows all logs for expectation matching, verification, clearing, etc
    
    Parameters:
    
    requestDefinition - the http request that is matched against when deciding whether to return each request, use null for the parameter to retrieve for all requests
    
    Returns:
    
    all log messages recorded by the MockServer when creating expectations, matching expectations, performing verification, clearing logs, etc
  - retrieveLogMessagesArray
```
public String[] retrieveLogMessagesArray(RequestDefinition requestDefinition)
```
    Retrieve the logs associated to a specific requests, this shows all logs for expectation matching, verification, clearing, etc
    
    Parameters:
    
    requestDefinition - the http request that is matched against when deciding whether to return each request, use null for the parameter to retrieve for all requests
    
    Returns:
    
    an array of all log messages recorded by the MockServer when creating expectations, matching expectations, performing verification, clearing logs, etc
  - when
```
public ForwardChainExpectation when(RequestDefinition requestDefinition)
```
    Specify an unlimited expectation that will respond regardless of the number of matching http for example:
```
 mockServerClient
  .when(
      request()
          .withPath("/some_path")
          .withBody("some_request_body")
  )
  .respond(
      response()
          .withBody("some_response_body")
          .withHeader("responseName", "responseValue")
  )
 
```
    Parameters:
    
    requestDefinition - the http request that must be matched for this expectation to respond
    
    Returns:
    
    an Expectation object that can be used to specify the response
  - when
```
public ForwardChainExpectation when(RequestDefinition requestDefinition,
                                    Times times)
```
    Specify a limited expectation that will respond a specified number of times when the http is matched
    Example use:
```
 mockServerClient
  .when(
      request()
          .withPath("/some_path")
          .withBody("some_request_body"),
      Times.exactly(5)
  )
  .respond(
      response()
          .withBody("some_response_body")
          .withHeader("responseName", "responseValue")
  )
 
```
    Parameters:
    
    requestDefinition - the http request that must be matched for this expectation to respond
    
    times - the number of times to respond when this http is matched
    
    Returns:
    
    an Expectation object that can be used to specify the response
  - when
```
public ForwardChainExpectation when(RequestDefinition requestDefinition,
                                    Times times,
                                    TimeToLive timeToLive)
```
    Specify a limited expectation that will respond a specified number of times when the http is matched
    Example use:
```
 mockServerClient
  .when(
      request()
          .withPath("/some_path")
          .withBody("some_request_body"),
      Times.exactly(5),
      TimeToLive.exactly(TimeUnit.SECONDS, 120)
  )
  .respond(
      response()
          .withBody("some_response_body")
          .withHeader("responseName", "responseValue")
  )
 
```
    Parameters:
    
    requestDefinition - the http request that must be matched for this expectation to respond
    
    times - the number of times to respond when this http is matched
    
    timeToLive - the length of time from when the server receives the expectation that the expectation should be active
    
    Returns:
    
    an Expectation object that can be used to specify the response
  - when
```
public ForwardChainExpectation when(RequestDefinition requestDefinition,
                                    Times times,
                                    TimeToLive timeToLive,
                                    Integer priority)
```
    Specify a limited expectation that will respond a specified number of times when the http is matched and will be matched according to priority as follows:
    - higher priority expectation will be matched first - identical priority expectations will be match in the order they were submitted - default priority is 0
    Example use:
```
 mockServerClient
  .when(
      request()
          .withPath("/some_path")
          .withBody("some_request_body"),
      Times.exactly(5),
      TimeToLive.exactly(TimeUnit.SECONDS, 120),
      10
  )
  .respond(
      response()
          .withBody("some_response_body")
          .withHeader("responseName", "responseValue")
  )
 
```
    Parameters:
    
    requestDefinition - the http request that must be matched for this expectation to respond
    
    times - the number of times to respond when this http is matched
    
    timeToLive - the length of time from when the server receives the expectation that the expectation should be active
    
    priority - the priority for the expectation when matching, higher priority expectation will be matched first, identical priority expectations will be match in the order they were submitted
    
    Returns:
    
    an Expectation object that can be used to specify the response
  - upsert
```
public Expectation[] upsert(OpenAPIExpectation... openAPIExpectations)
```
    Specify OpenAPI and operations and responses to create matchers and example responses
    
    Parameters:
    
    openAPIExpectations - the OpenAPI and operations and responses to create matchers and example responses
    
    Returns:
    
    upserted expectations
  - upsert
```
public Expectation[] upsert(Expectation... expectations)
```
    Specify one or more expectations to be create, or updated (if the id matches).
    This method should be used to update existing expectation by id. All fields will be updated for expectations with a matching id as the existing expectation is deleted and recreated.
    To retrieve the id(s) for existing expectation(s) the retrieveActiveExpectations(HttpRequest httpRequest) method can be used.
    Typically, to create expectations this method should not be used directly instead the when(...) and response(...) or forward(...) or error(...) methods should be used for example:
```
 mockServerClient
  .when(
      request()
          .withPath("/some_path")
          .withBody("some_request_body"),
      Times.exactly(5),
      TimeToLive.exactly(TimeUnit.SECONDS, 120)
  )
  .respond(
      response()
          .withBody("some_response_body")
          .withHeader("responseName", "responseValue")
  )
 
```
    Parameters:
    
    expectations - one or more expectations to create or update (if the id field matches)
    
    Returns:
    
    upserted expectations
  - sendExpectation
```
@Deprecated
public Expectation[] sendExpectation(Expectation... expectations)
```
    Deprecated. this is deprecated due to unclear naming, use method upsert(Expectation... expectations) instead
    Specify one or more expectations, normally this method should not be used directly instead the when(...) and response(...) or forward(...) or error(...) methods should be used for example:
```
 mockServerClient
  .when(
      request()
          .withPath("/some_path")
          .withBody("some_request_body"),
      Times.exactly(5),
      TimeToLive.exactly(TimeUnit.SECONDS, 120)
  )
  .respond(
      response()
          .withBody("some_response_body")
          .withHeader("responseName", "responseValue")
  )
 
```
    Parameters:
    
    expectations - one or more expectations
    
    Returns:
    
    added or updated expectations
  - retrieveActiveExpectations
```
public Expectation[] retrieveActiveExpectations(RequestDefinition requestDefinition)
```
    Retrieve the active expectations match the httpRequest parameter, use null for the parameter to retrieve all expectations
    
    Parameters:
    
    requestDefinition - the http request that is matched against when deciding whether to return each expectation, use null for the parameter to retrieve for all requests
    
    Returns:
    
    an array of all expectations that have been setup and have not expired
  - retrieveActiveExpectations
```
public String retrieveActiveExpectations(RequestDefinition requestDefinition,
                                         Format format)
```
    Retrieve the active expectations match the httpRequest parameter, use null for the parameter to retrieve all expectations
    
    Parameters:
    
    requestDefinition - the http request that is matched against when deciding whether to return each expectation, use null for the parameter to retrieve for all requests
    
    format - the format to retrieve the expectations, either JAVA or JSON
    
    Returns:
    
    an array of all expectations that have been setup and have not expired

Class MockServerClient

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

portFuture

Constructor Detail

MockServerClient

MockServerClient

MockServerClient

MockServerClient

MockServerClient

MockServerClient

MockServerClient

MockServerClient

Method Detail

setProxyConfiguration

withProxyConfiguration

withControlPlaneJWT

withControlPlaneJWT

setRequestOverride

withRequestOverride

isSecure

withSecure

remoteAddress

contextPath

getPort

openUI

openUI

isRunning

isRunning

hasStopped

hasStopped

hasStarted

hasStarted

bind

stopAsync

stop

stop

close

reset

clear

clear

clear

clear

clear

clear

verify

verify

verify

verify

verify

verify

verify

verify

verify

verify

verifyZeroInteractions

retrieveRecordedRequests

retrieveRecordedRequests

retrieveRecordedRequestsAndResponses

retrieveRecordedRequestsAndResponses

retrieveRecordedExpectations

retrieveRecordedExpectations

retrieveLogMessages

retrieveLogMessagesArray

when

when

when

when

upsert

upsert

sendExpectation

retrieveActiveExpectations

retrieveActiveExpectations