MockServer Clients | MockServer

MockServer can be controlled in the following ways:

REST API
Java
JavaScript (both browser API & Node.js module)
Python (sync and async)
Ruby
Go
.NET
Rust
PHP

The following activities are supported:

starting a local MockServer by downloading and launching the self-contained platform binary (Node, Python, Ruby, Go, .NET and Rust clients)
creating expectations
verifying which requests have been received
clearing or resetting recorded request, expectations or logs (selectively)
Retrieving the following items:
- recorded requests
- recorded requests and responses
- active expectations
- recorded expectations
- logs
bind additional ports for MockServer to listen on

REST API

The REST API is documented using Open API 3

Java Client

The Java client has the following versions:

org.mockserver.client.MockServerClient - makes HTTP requests to a remote MockServer instance
org.mockserver.integration.ClientAndServer - starts a local MockServer instance and makes HTTP requests to it

Install via Maven:

<dependency>
    <groupId>org.mock-server</groupId>
    <artifactId>mockserver-client-java</artifactId>
    <version>7.1.0</version>
</dependency>

Create an expectation:

import static org.mockserver.model.HttpRequest.request;
import static org.mockserver.model.HttpResponse.response;

new MockServerClient("localhost", 1080)
    .when(
        request().withMethod("GET").withPath("/hello")
    )
    .respond(
        response().withStatusCode(200).withBody("world")
    );

Verify a request was received:

import static org.mockserver.model.HttpRequest.request;
import org.mockserver.verify.VerificationTimes;

new MockServerClient("localhost", 1080)
    .verify(
        request().withPath("/some/path"),
        VerificationTimes.atLeast(1)
    );

JavaScript Client

The JavaScript client has the following version:

a browser based API file mockServerClient.js
a Node.js npm module mockserver-client

To include the browser based client in an HTML page as follows:

<script src="https://raw.githubusercontent.com/mock-server/mockserver-monorepo/master/mockserver-client-node/mockServerClient.js"></script>

Or install the Node.js module via npm:

npm install mockserver-client --save-dev

Create an expectation:

const mockServerClient = require('mockserver-client').mockServerClient;

mockServerClient("localhost", 1080).mockAnyResponse({
    httpRequest: { method: "GET", path: "/hello" },
    httpResponse: { statusCode: 200, body: "world" }
});

Verify a request was received:

const mockServerClient = require('mockserver-client').mockServerClient;

mockServerClient("localhost", 1080)
    .verify({ path: "/some/path" }, 1)
    .then(
        function () { /* request was received at least once */ },
        function () { /* verification failed */ }
    );

Python Client

The Python client provides both synchronous and asynchronous APIs:

MockServerClient - synchronous client wrapping the async implementation
AsyncMockServerClient - native async client using asyncio

Install via pip:

pip install mockserver-client

The synchronous client supports context manager usage:

from mockserver import MockServerClient, HttpRequest, HttpResponse

with MockServerClient("localhost", 1080) as client:
    client.when(
        HttpRequest(path="/hello")
    ).respond(
        HttpResponse(status_code=200, body="world")
    )

The async client can be used with async with:

from mockserver import AsyncMockServerClient, HttpRequest, HttpResponse

async with AsyncMockServerClient("localhost", 1080) as client:
    await client.when(
        HttpRequest(path="/hello")
    ).respond(
        HttpResponse(status_code=200, body="world")
    )

Verification failures raise MockServerVerificationError (a subclass of both MockServerError and AssertionError). Connection failures raise MockServerConnectionError:

from mockserver import MockServerClient, HttpRequest, VerificationTimes
from mockserver.exceptions import MockServerVerificationError, MockServerConnectionError

try:
    with MockServerClient("localhost", 1080) as client:
        client.verify(HttpRequest(path="/some/path"), times=VerificationTimes(at_least=1))
except MockServerVerificationError as e:
    print(f"Verification failed: {e}")
except MockServerConnectionError as e:
    print(f"Connection failed: {e}")

Requires Python >= 3.9.

Ruby Client

The Ruby client provides a fluent builder DSL and WebSocket-based callback support:

MockServer::Client - makes HTTP requests to a remote MockServer instance

Install via gem:

gem install mockserver-client

The client supports a block form for automatic cleanup:

require 'mockserver-client'

MockServer::Client.new('localhost', 1080) do |client|
  client.when(
    MockServer::HttpRequest.new(path: '/hello')
  ).respond(
    MockServer::HttpResponse.new(body: 'world')
  )
end

You can include MockServer to use shorter class names (e.g. HttpRequest instead of MockServer::HttpRequest). All accordion examples below use this pattern for brevity.

Verification failures raise MockServer::VerificationError. Connection failures raise MockServer::ConnectionError:

require 'mockserver-client'
include MockServer

MockServer::Client.new('localhost', 1080) do |client|
  client.verify(HttpRequest.new(path: '/some/path'), times: VerificationTimes.at_least(1))
rescue MockServer::VerificationError => e
  puts "Verification failed: #{e.message}"
rescue MockServer::ConnectionError => e
  puts "Connection failed: #{e.message}"
end

Requires Ruby >= 3.0.

Go Client

The Go client provides a fluent builder API with zero third-party dependencies (standard library only):

mockserver.Client - makes HTTP requests to a remote MockServer instance

Install via go get:

go get github.com/mock-server/mockserver-monorepo/mockserver-client-go

Create an expectation using the fluent API:

import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go"

client := mockserver.New("localhost", 1080)
client.When(
    mockserver.Request().Method("GET").Path("/hello"),
).Respond(
    mockserver.Response().StatusCode(200).Body("world"),
)

Verification failures return a *mockserver.VerificationError:

import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go"

client := mockserver.New("localhost", 1080)
err := client.Verify(
    mockserver.Request().Path("/some/path"),
    mockserver.AtLeast(1),
)
if err != nil {
    log.Fatal(err)
}

Requires Go >= 1.21.

Available from MockServer 7.1.0 — the module is published (tag mockserver-client-go/v7.1.0) with that release.

.NET Client

The .NET client provides a fluent builder API with synchronous and async variants for all operations:

MockServerClient - makes HTTP requests to a remote MockServer instance

The NuGet package is MockServerClient (the C# namespace remains MockServer.Client). Install via dotnet add:

dotnet add package MockServerClient

Or via PackageReference in your .csproj:

<PackageReference Include="MockServerClient" Version="7.1.0" />

Available from MockServer 7.1.0 — the MockServerClient package is published to NuGet with that release.

Create an expectation using the fluent API:

using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);
client.When(
    HttpRequest.Request()
        .WithMethod("GET")
        .WithPath("/hello")
).Respond(
    HttpResponse.Response()
        .WithStatusCode(200)
        .WithBody("world")
);

Verification failures throw VerificationException. Connection failures throw MockServerClientException:

using MockServer.Client;
using MockServer.Client.Models;
using MockServer.Client.Exceptions;

try
{
    using var client = new MockServerClient("localhost", 1080);
    client.Verify(
        HttpRequest.Request().WithPath("/some/path"),
        VerificationTimes.AtLeastTimes(1)
    );
}
catch (VerificationException e)
{
    Console.WriteLine($"Verification failed: {e.Message}");
}
catch (MockServerClientException e)
{
    Console.WriteLine($"Connection failed: {e.Message}");
}

Supports .NET Standard 2.0 (.NET Framework 4.6.1+, .NET Core 2.0+, and Mono 5.4+) and .NET 8.0.

Rust Client

The Rust client provides a fluent builder API using the blocking reqwest client:

MockServerClient - makes HTTP requests to a remote MockServer instance

Add to your Cargo.toml:

[dev-dependencies]
mockserver-client = "7.0"

Create an expectation using the fluent API:

use mockserver_client::{ClientBuilder, HttpRequest, HttpResponse};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
client.when(HttpRequest::new().method("GET").path("/hello"))
    .respond(HttpResponse::new().status_code(200).body("world"))
    .unwrap();

Verification failures return Err(Error::VerificationFailure):

use mockserver_client::{ClientBuilder, HttpRequest, VerificationTimes};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
client.verify(
    HttpRequest::new().path("/some/path"),
    VerificationTimes::at_least(1),
).unwrap();

Requires Rust 2021 edition.

Available from MockServer 7.1.0 — the mockserver-client crate is published to crates.io with that release.

PHP Client

The PHP client provides a fluent builder API using Guzzle for HTTP transport:

MockServerClient - makes HTTP requests to a remote MockServer instance

Install via Composer:

composer require mock-server/mockserver-client

Create an expectation using the fluent API:

use MockServer\MockServerClient;
use MockServer\HttpRequest;
use MockServer\HttpResponse;

$client = new MockServerClient('localhost', 1080);
$client->when(
    HttpRequest::request()->method('GET')->path('/hello')
)->respond(
    HttpResponse::response()->statusCode(200)->body('world')
);

Verification failures throw MockServer\Exception\VerificationException. Connection failures throw MockServer\Exception\ConnectionException:

use MockServer\MockServerClient;
use MockServer\HttpRequest;
use MockServer\VerificationTimes;
use MockServer\Exception\VerificationException;
use MockServer\Exception\ConnectionException;

try {
    $client = new MockServerClient('localhost', 1080);
    $client->verify(
        HttpRequest::request()->path('/some/path'),
        VerificationTimes::atLeast(1)
    );
} catch (VerificationException $e) {
    echo "Verification failed: " . $e->getMessage();
} catch (ConnectionException $e) {
    echo "Connection failed: " . $e->getMessage();
}

Requires PHP >= 8.1.

Available from MockServer 7.1.0 — the mock-server/mockserver-client package is published to Packagist with that release.

new MockServerClient("localhost", 1080)
    .when(
        request()
            .withMethod("GET")
            .withPath("/view/cart")
            .withCookies(
                cookie("session", "4930456C-C718-476F-971F-CB8E047AB349")
            )
            .withQueryStringParameters(
                param("cartId", "055CA455-1DF7-45BB-8535-4F83E7266092")
            )
    )
    .respond(
        response()
            .withBody("some_response_body")
    );

new ClientAndServer(1080)
    .when(
        request()
            .withMethod("GET")
            .withPath("/view/cart")
            .withCookies(
                cookie("session", "4930456C-C718-476F-971F-CB8E047AB349")
            )
            .withQueryStringParameters(
                param("cartId", "055CA455-1DF7-45BB-8535-4F83E7266092")
            )
    )
    .respond(
        response()
            .withBody("some_response_body")
    );

var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
  .mockAnyResponse({
    "httpRequest": {
      "method": "GET",
      "path": "/view/cart",
      "queryStringParameters": {
        "cartId": ["055CA455-1DF7-45BB-8535-4F83E7266092"]
      },
      "cookies": {
        "session": "4930456C-C718-476F-971F-CB8E047AB349"
      }
    },
    "httpResponse": {
      "body": "some_response_body"
    }
  })
  .then(
    function () {
      console.log("expectation created");
    },
    function (error) {
      console.log(error);
    }
  );

<script src="https://raw.githubusercontent.com/mock-server/mockserver-monorepo/master/mockserver-client-node/mockServerClient.js"></script>
<script>
  mockServerClient("localhost", 1080)
    .mockAnyResponse({
      "httpRequest": {
        "method": "GET",
        "path": "/view/cart",
        "queryStringParameters": {
          "cartId": ["055CA455-1DF7-45BB-8535-4F83E7266092"]
        },
        "cookies": {
          "session": "4930456C-C718-476F-971F-CB8E047AB349"
        }
      },
      "httpResponse": {
        "body": "some_response_body"
      }
    })
    .then(
      function () {
        console.log("expectation created");
      },
      function (error) {
        console.log(error);
      }
    );
</script>

from mockserver import MockServerClient, HttpRequest, HttpResponse, KeyToMultiValue

client = MockServerClient("localhost", 1080)
client.when(
    HttpRequest(
        method="GET",
        path="/view/cart",
        cookies=[KeyToMultiValue(name="session", values=["4930456C-C718-476F-971F-CB8E047AB349"])],
        query_string_parameters=[KeyToMultiValue(name="cartId", values=["055CA455-1DF7-45BB-8535-4F83E7266092"])]
    )
).respond(
    HttpResponse(body="some_response_body")
)

require 'mockserver-client'
include MockServer

client = MockServer::Client.new('localhost', 1080)
client.when(
  HttpRequest.new(
    method: 'GET',
    path: '/view/cart',
    cookies: [{ name: 'session', values: ['4930456C-C718-476F-971F-CB8E047AB349'] }],
    query_string_parameters: [{ name: 'cartId', values: ['055CA455-1DF7-45BB-8535-4F83E7266092'] }]
  )
).respond(
  HttpResponse.new(body: 'some_response_body')
)

import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go"

client := mockserver.New("localhost", 1080)
client.When(
    mockserver.Request().
        Method("GET").
        Path("/view/cart").
        Cookie("session", "4930456C-C718-476F-971F-CB8E047AB349").
        QueryStringParameter("cartId", "055CA455-1DF7-45BB-8535-4F83E7266092"),
).Respond(
    mockserver.Response().Body("some_response_body"),
)

using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);
// .NET client uses raw JSON for cookie matchers
client.Upsert(new Expectation
{
    HttpRequest = new HttpRequest
    {
        Method = "GET",
        Path = "/view/cart",
        QueryStringParameters = new Dictionary<string, List<string>>
        {
            { "cartId", new List<string> { "055CA455-1DF7-45BB-8535-4F83E7266092" } }
        }
    },
    HttpResponse = new HttpResponse { Body = "some_response_body" }
});

use mockserver_client::{ClientBuilder, HttpRequest, HttpResponse};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
client.when(
    HttpRequest::new()
        .method("GET")
        .path("/view/cart")
        .query_param("cartId", "055CA455-1DF7-45BB-8535-4F83E7266092"),
).respond(
    HttpResponse::new().body("some_response_body"),
).unwrap();

use MockServer\MockServerClient;
use MockServer\HttpRequest;
use MockServer\HttpResponse;

$client = new MockServerClient('localhost', 1080);
$client->when(
    HttpRequest::request()
        ->method('GET')
        ->path('/view/cart')
        ->cookie('session', '4930456C-C718-476F-971F-CB8E047AB349')
        ->queryStringParameter('cartId', '055CA455-1DF7-45BB-8535-4F83E7266092')
)->respond(
    HttpResponse::response()->body('some_response_body')
);

curl -v -X PUT "http://localhost:1080/mockserver/expectation" -d '{
  "httpRequest" : {
    "method" : "GET",
    "path" : "/view/cart",
    "queryStringParameters" : {
      "cartId" : [ "055CA455-1DF7-45BB-8535-4F83E7266092" ]
    },
    "cookies" : {
      "session" : "4930456C-C718-476F-971F-CB8E047AB349"
    }
  },
  "httpResponse" : {
    "body" : "some_response_body"
  }
}'

new MockServerClient("localhost", 1080)
    .withSecure(true)
    .when(
        request()
            .withMethod("GET")
            .withPath("/view/cart")
            .withCookies(
                cookie("session", "4930456C-C718-476F-971F-CB8E047AB349")
            )
            .withQueryStringParameters(
                param("cartId", "055CA455-1DF7-45BB-8535-4F83E7266092")
            )
    )
    .respond(
        response()
            .withBody("some_response_body")
    );

new ClientAndServer(1080)
    .withSecure(true)
    .when(
        request()
            .withMethod("GET")
            .withPath("/view/cart")
            .withCookies(
                cookie("session", "4930456C-C718-476F-971F-CB8E047AB349")
            )
            .withQueryStringParameters(
                param("cartId", "055CA455-1DF7-45BB-8535-4F83E7266092")
            )
    )
    .respond(
        response()
            .withBody("some_response_body")
    );

var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080, undefined, true)
  .mockAnyResponse({
    "httpRequest": {
      "method": "GET",
      "path": "/view/cart",
      "queryStringParameters": {
        "cartId": ["055CA455-1DF7-45BB-8535-4F83E7266092"]
      },
      "cookies": {
        "session": "4930456C-C718-476F-971F-CB8E047AB349"
      }
    },
    "httpResponse": {
      "body": "some_response_body"
    }
  })
  .then(
    function () {
      console.log("expectation created");
    },
    function (error) {
      console.log(error);
    }
  );

from mockserver import MockServerClient, HttpRequest, HttpResponse, KeyToMultiValue

client = MockServerClient("localhost", 1080, secure=True, tls_verify=False)
client.when(
    HttpRequest(
        method="GET",
        path="/view/cart",
        cookies=[KeyToMultiValue(name="session", values=["4930456C-C718-476F-971F-CB8E047AB349"])],
        query_string_parameters=[KeyToMultiValue(name="cartId", values=["055CA455-1DF7-45BB-8535-4F83E7266092"])]
    )
).respond(
    HttpResponse(body="some_response_body")
)

require 'mockserver-client'
include MockServer

client = MockServer::Client.new('localhost', 1080, secure: true, tls_verify: false)
client.when(
  HttpRequest.new(
    method: 'GET',
    path: '/view/cart',
    cookies: [{ name: 'session', values: ['4930456C-C718-476F-971F-CB8E047AB349'] }],
    query_string_parameters: [{ name: 'cartId', values: ['055CA455-1DF7-45BB-8535-4F83E7266092'] }]
  )
).respond(
  HttpResponse.new(body: 'some_response_body')
)

import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go"

client := mockserver.New("localhost", 1080, mockserver.WithTLS())
client.When(
    mockserver.Request().
        Method("GET").
        Path("/view/cart").
        Cookie("session", "4930456C-C718-476F-971F-CB8E047AB349").
        QueryStringParameter("cartId", "055CA455-1DF7-45BB-8535-4F83E7266092"),
).Respond(
    mockserver.Response().Body("some_response_body"),
)

using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080, secure: true);
client.When(
    HttpRequest.Request()
        .WithMethod("GET")
        .WithPath("/view/cart")
        .WithQueryStringParameter("cartId", "055CA455-1DF7-45BB-8535-4F83E7266092")
).Respond(
    HttpResponse.Response().WithBody("some_response_body")
);

use mockserver_client::{ClientBuilder, HttpRequest, HttpResponse};

let client = ClientBuilder::new("localhost", 1080)
    .secure(true)
    .tls_verify(false)
    .build()
    .unwrap();
client.when(
    HttpRequest::new()
        .method("GET")
        .path("/view/cart")
        .query_param("cartId", "055CA455-1DF7-45BB-8535-4F83E7266092"),
).respond(
    HttpResponse::new().body("some_response_body"),
).unwrap();

use MockServer\MockServerClient;
use MockServer\HttpRequest;
use MockServer\HttpResponse;

$client = new MockServerClient('localhost', 1080, secure: true, guzzleOptions: [
    'verify' => false,
]);
$client->when(
    HttpRequest::request()
        ->method('GET')
        ->path('/view/cart')
        ->queryStringParameter('cartId', '055CA455-1DF7-45BB-8535-4F83E7266092')
)->respond(
    HttpResponse::response()->body('some_response_body')
);

curl -v -k -X PUT "https://localhost:1080/mockserver/expectation" -d '{
  "httpRequest" : {
    "method" : "GET",
    "path" : "/view/cart",
    "queryStringParameters" : {
      "cartId" : [ "055CA455-1DF7-45BB-8535-4F83E7266092" ]
    },
    "cookies" : {
      "session" : "4930456C-C718-476F-971F-CB8E047AB349"
    }
  },
  "httpResponse" : {
    "body" : "some_response_body"
  }
}'

new MockServerClient("localhost", 1080)
    .verify(
        request()
            .withPath("/some/path"),
        VerificationTimes.atLeast(2)
    );

new ClientAndServer(1080)
    .verify(
        request()
            .withPath("/some/path"),
        VerificationTimes.atLeast(2)
    );

var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
  .verify(
    {
      'path': '/some/path'
    }, 2, false)
  .then(
    function () {
      console.log("request found exactly 2 times");
    },
    function (error) {
      console.log(error);
    }
  );

<script src="https://raw.githubusercontent.com/mock-server/mockserver-monorepo/master/mockserver-client-node/mockServerClient.js"></script>
<script>
  mockServerClient("localhost", 1080)
    .verify(
      {
        'path': '/some/path'
      }, 2, false)
    .then(
      function () {
        console.log("request found exactly 2 times");
      },
      function (error) {
        console.log(error);
      }
    );
</script>

from mockserver import MockServerClient, HttpRequest, VerificationTimes

client = MockServerClient("localhost", 1080)
client.verify(
    HttpRequest(path="/some/path"),
    times=VerificationTimes(at_least=2)
)

require 'mockserver-client'
include MockServer

client = MockServer::Client.new('localhost', 1080)
client.verify(
  HttpRequest.new(path: '/some/path'),
  times: VerificationTimes.at_least(2)
)

import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go"

client := mockserver.New("localhost", 1080)
err := client.Verify(
    mockserver.Request().Path("/some/path"),
    mockserver.ExactlyTimes(2),
)
if err != nil {
    log.Fatal(err)
}

using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);
client.Verify(
    HttpRequest.Request().WithPath("/some/path"),
    VerificationTimes.ExactlyTimes(2)
);

use mockserver_client::{ClientBuilder, HttpRequest, VerificationTimes};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
client.verify(
    HttpRequest::new().path("/some/path"),
    VerificationTimes::exactly(2),
).unwrap();

use MockServer\MockServerClient;
use MockServer\HttpRequest;
use MockServer\VerificationTimes;

$client = new MockServerClient('localhost', 1080);
$client->verify(
    HttpRequest::request()->path('/some/path'),
    VerificationTimes::exactly(2)
);

curl -v -X PUT "http://localhost:1080/mockserver/verify" -d '{
    "httpRequest": {
        "path": "/simple"
    },
    "times": {
        "atLeast": 2,
        "atMost": 2
    }
}'

new MockServerClient("localhost", 1080)
    .verify(
        request()
            .withPath("/some/path/one"),
        request()
            .withPath("/some/path/two"),
        request()
            .withPath("/some/path/three")
    );

new ClientAndServer(1080)
    .verify(
        request()
            .withPath("/some/path/one"),
        request()
            .withPath("/some/path/two"),
        request()
            .withPath("/some/path/three")
    );

var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
  .verifySequence(
    {
      'path': '/some/path/one'
    },
    {
      'path': '/some/path/two'
    },
    {
      'path': '/some/path/three'
    }
  )
  .then(
    function () {
      console.log("request sequence found in the order specified");
    },
    function (error) {
      console.log(error);
    }
  );

<script src="https://raw.githubusercontent.com/mock-server/mockserver-monorepo/master/mockserver-client-node/mockServerClient.js"></script>
<script>
  mockServerClient("localhost", 1080)
    .verifySequence(
      {
        'path': '/some/path/one'
      },
      {
        'path': '/some/path/two'
      },
      {
        'path': '/some/path/three'
      }
    )
    .then(
      function () {
        console.log("request sequence found in the order specified");
      },
      function (error) {
        console.log(error);
      }
    );
</script>

from mockserver import MockServerClient, HttpRequest

client = MockServerClient("localhost", 1080)
client.verify_sequence(
    HttpRequest(path="/some/path/one"),
    HttpRequest(path="/some/path/two"),
    HttpRequest(path="/some/path/three")
)

require 'mockserver-client'
include MockServer

client = MockServer::Client.new('localhost', 1080)
client.verify_sequence(
  HttpRequest.new(path: '/some/path/one'),
  HttpRequest.new(path: '/some/path/two'),
  HttpRequest.new(path: '/some/path/three')
)

import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go"

client := mockserver.New("localhost", 1080)
err := client.VerifySequence(
    mockserver.Request().Path("/some/path/one"),
    mockserver.Request().Path("/some/path/two"),
    mockserver.Request().Path("/some/path/three"),
)
if err != nil {
    log.Fatal(err)
}

using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);
client.VerifySequence(
    HttpRequest.Request().WithPath("/some/path/one"),
    HttpRequest.Request().WithPath("/some/path/two"),
    HttpRequest.Request().WithPath("/some/path/three")
);

use mockserver_client::{ClientBuilder, HttpRequest};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
client.verify_sequence(vec![
    HttpRequest::new().path("/some/path/one"),
    HttpRequest::new().path("/some/path/two"),
    HttpRequest::new().path("/some/path/three"),
]).unwrap();

use MockServer\MockServerClient;
use MockServer\HttpRequest;

$client = new MockServerClient('localhost', 1080);
$client->verifySequence(
    HttpRequest::request()->path('/some/path/one'),
    HttpRequest::request()->path('/some/path/two'),
    HttpRequest::request()->path('/some/path/three')
);

curl -v -X PUT "http://localhost:1080/mockserver/verifySequence" -d '{
   "httpRequests":[
      {
         "path":"/some/path/one"
      },
      {
         "path":"/some/path/two"
      },
      {
         "path":"/some/path/three"
      }
   ]
}'

HttpRequest[] recordedRequests = new MockServerClient("localhost", 1080)
    .retrieveRecordedRequests(
        request()
            .withPath("/some/path")
            .withMethod("POST")
    );

HttpRequest[] recordedRequests = new ClientAndServer(1080)
    .retrieveRecordedRequests(
        request()
            .withPath("/some/path")
            .withMethod("POST")
    );

var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
  .retrieveRecordedRequests({
    "path": "/some/path",
    "method": "POST"
  })
  .then(
    function (recordedRequests) {
      console.log(JSON.stringify(recordedRequests));
    },
    function (error) {
      console.log(error);
    }
  );

<script src="https://raw.githubusercontent.com/mock-server/mockserver-monorepo/master/mockserver-client-node/mockServerClient.js"></script>
<script>
  mockServerClient("localhost", 1080)
    .retrieveRecordedRequests({
      "path": "/some/path",
      "method": "POST"
    })
    .then(
      function (recordedRequests) {
        console.log(JSON.stringify(recordedRequests));
      },
      function (error) {
        console.log(error);
      }
    );
</script>

from mockserver import MockServerClient, HttpRequest

client = MockServerClient("localhost", 1080)
recorded_requests = client.retrieve_recorded_requests(
    HttpRequest(path="/some/path", method="POST")
)

require 'mockserver-client'
include MockServer

client = MockServer::Client.new('localhost', 1080)
recorded_requests = client.retrieve_recorded_requests(
  request: HttpRequest.new(path: '/some/path', method: 'POST')
)

import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go"

client := mockserver.New("localhost", 1080)
recordedRequests, err := client.RetrieveRecordedRequests(
    mockserver.Request().Path("/some/path").Method("POST"),
)
if err != nil {
    log.Fatal(err)
}

using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);
var recordedRequests = client.RetrieveRecordedRequests(
    HttpRequest.Request().WithPath("/some/path").WithMethod("POST")
);

use mockserver_client::{ClientBuilder, HttpRequest};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
let recorded_requests = client.retrieve_recorded_requests(
    Some(&HttpRequest::new().path("/some/path").method("POST")),
).unwrap();

use MockServer\MockServerClient;
use MockServer\HttpRequest;

$client = new MockServerClient('localhost', 1080);
$recordedRequests = $client->retrieveRecordedRequests(
    HttpRequest::request()->path('/some/path')->method('POST')
);

curl -v -X PUT "http://localhost:1080/mockserver/retrieve?type=REQUESTS" -d '{
    "path": "/some/path",
    "method": "POST"
}'

Expectation[] recordedExpectations = new MockServerClient("localhost", 1080)
    .retrieveRecordedExpectations(
        request()
            .withPath("/some/path")
            .withMethod("POST")
    );

Expectation[] recordedExpectations = new ClientAndServer(1080)
    .retrieveRecordedExpectations(
        request()
            .withPath("/some/path")
            .withMethod("POST")
    );

var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
  .retrieveRecordedExpectations({
    "path": "/some/path",
    "method": "POST"
  })
  .then(
    function (recordedExpectations) {
      console.log(JSON.stringify(recordedExpectations));
    },
    function (error) {
      console.log(error);
    }
  );

<script src="https://raw.githubusercontent.com/mock-server/mockserver-monorepo/master/mockserver-client-node/mockServerClient.js"></script>
<script>
  mockServerClient("localhost", 1080)
    .retrieveRecordedExpectations({
      "path": "/some/path",
      "method": "POST"
    })
    .then(
      function (recordedExpectations) {
        console.log(JSON.stringify(recordedExpectations));
      },
      function (error) {
        console.log(error);
      }
    );
</script>

from mockserver import MockServerClient, HttpRequest

client = MockServerClient("localhost", 1080)
recorded_expectations = client.retrieve_recorded_expectations(
    HttpRequest(path="/some/path", method="POST")
)

require 'mockserver-client'
include MockServer

client = MockServer::Client.new('localhost', 1080)
recorded_expectations = client.retrieve_recorded_expectations(
  request: HttpRequest.new(path: '/some/path', method: 'POST')
)

import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go"

client := mockserver.New("localhost", 1080)
recordedExpectations, err := client.RetrieveRecordedExpectations(
    mockserver.Request().Path("/some/path").Method("POST"),
)
if err != nil {
    log.Fatal(err)
}

using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);
var recordedExpectations = client.RetrieveRecordedExpectations(
    HttpRequest.Request().WithPath("/some/path").WithMethod("POST")
);

use mockserver_client::{ClientBuilder, HttpRequest};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
let recorded_expectations = client.retrieve_recorded_expectations(
    Some(&HttpRequest::new().path("/some/path").method("POST")),
).unwrap();

use MockServer\MockServerClient;
use MockServer\HttpRequest;

$client = new MockServerClient('localhost', 1080);
$recordedExpectations = $client->retrieveRecordedExpectations(
    HttpRequest::request()->path('/some/path')->method('POST')
);

curl -v -X PUT "http://localhost:1080/mockserver/retrieve?type=RECORDED_EXPECTATIONS" -d '{
    "path": "/some/path",
    "method": "POST"
}'

// retrieveLogMessagesArray returns a String[] of formatted log messages;
// use retrieveLogMessages(...) for a single String containing all messages
String[] logMessages = new MockServerClient("localhost", 1080)
    .retrieveLogMessagesArray(
        request()
            .withPath("/some/path")
            .withMethod("POST")
    );

// retrieveLogMessagesArray returns a String[] of formatted log messages;
// use retrieveLogMessages(...) for a single String containing all messages
String[] logMessages = new ClientAndServer(1080)
    .retrieveLogMessagesArray(
        request()
            .withPath("/some/path")
            .withMethod("POST")
    );

var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
  .retrieveLogMessages({
    "path": "/some/path",
    "method": "POST"
  })
  .then(
    function (logMessages) {
      // logMessages is a String[]
      console.log(logMessages);
    },
    function (error) {
      console.log(error);
    }
  );

<script src="https://raw.githubusercontent.com/mock-server/mockserver-monorepo/master/mockserver-client-node/mockServerClient.js"></script>
<script>
  mockServerClient("localhost", 1080)
    .retrieveLogMessages({
      "path": "/some/path",
      "method": "POST"
    })
    .then(
      function (logMessages) {
        // logMessages is a String[]
        console.log(logMessages);
      },
      function (error) {
        console.log(error);
      }
    );
</script>

from mockserver import MockServerClient, HttpRequest

client = MockServerClient("localhost", 1080)
log_messages = client.retrieve_log_messages(
    HttpRequest(path="/some/path", method="POST")
)

require 'mockserver-client'
include MockServer

client = MockServer::Client.new('localhost', 1080)
log_messages = client.retrieve_log_messages(
  request: HttpRequest.new(path: '/some/path', method: 'POST')
)

import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go"

client := mockserver.New("localhost", 1080)
logMessages, err := client.RetrieveLogMessages(
    mockserver.Request().Path("/some/path").Method("POST"),
)
if err != nil {
    log.Fatal(err)
}

using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);
var logMessages = client.RetrieveLogMessages(
    HttpRequest.Request().WithPath("/some/path").WithMethod("POST")
);

use mockserver_client::{ClientBuilder, HttpRequest};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
let log_messages = client.retrieve_log_messages(
    Some(&HttpRequest::new().path("/some/path").method("POST")),
).unwrap();

use MockServer\MockServerClient;
use MockServer\HttpRequest;

$client = new MockServerClient('localhost', 1080);
$logMessages = $client->retrieveLogMessages(
    HttpRequest::request()->path('/some/path')->method('POST')
);

curl -v -X PUT "http://localhost:1080/mockserver/retrieve?type=LOGS" -d '{
    "path": "/some/path",
    "method": "POST"
}'

new MockServerClient("localhost", 1080).clear(
    request()
        .withPath("/some/path")
        .withMethod("POST")
);

new ClientAndServer(1080).clear(
    request()
        .withPath("/some/path")
        .withMethod("POST")
);

var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
  .clear({
    'path': '/some/path'
  })
  .then(
    function () {
      console.log("cleared state that matches request matcher");
    },
    function (error) {
      console.log(error);
    }
  );

<script src="https://raw.githubusercontent.com/mock-server/mockserver-monorepo/master/mockserver-client-node/mockServerClient.js"></script>
<script>
  mockServerClient("localhost", 1080)
    .clear({
      'path': '/some/path'
    })
    .then(
      function () {
        console.log("cleared state that matches request matcher");
      },
      function (error) {
        console.log(error);
      }
    );
</script>

from mockserver import MockServerClient, HttpRequest

client = MockServerClient("localhost", 1080)
client.clear(HttpRequest(path="/some/path"))

require 'mockserver-client'
include MockServer

client = MockServer::Client.new('localhost', 1080)
client.clear(HttpRequest.new(path: '/some/path'))

import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go"

client := mockserver.New("localhost", 1080)
err := client.Clear(
    mockserver.Request().Path("/some/path"),
    mockserver.ClearAll,
)
if err != nil {
    log.Fatal(err)
}

using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);
client.Clear(HttpRequest.Request().WithPath("/some/path"));

use mockserver_client::{ClientBuilder, HttpRequest};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
client.clear(
    Some(&HttpRequest::new().path("/some/path")),
    None,
).unwrap();

use MockServer\MockServerClient;
use MockServer\HttpRequest;

$client = new MockServerClient('localhost', 1080);
$client->clear(HttpRequest::request()->path('/some/path'));

curl -v -X PUT "http://localhost:1080/mockserver/clear" -d '{
    "path": "/some/path"
}'

new MockServerClient("localhost", 1080).clear(
    request()
        .withPath("/some/path")
        .withMethod("POST"),
    ClearType.LOG
);

new ClientAndServer(1080).clear(
    request()
        .withPath("/some/path")
        .withMethod("POST"),
    ClearType.LOG
);

var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
  .clear({
    'path': '/some/path'
  }, 'LOG')
  .then(
    function () {
      console.log("cleared state that matches request matcher");
    },
    function (error) {
      console.log(error);
    }
  );

<script src="https://raw.githubusercontent.com/mock-server/mockserver-monorepo/master/mockserver-client-node/mockServerClient.js"></script>
<script>
  mockServerClient("localhost", 1080)
    .clear({
      'path': '/some/path'
    }, 'LOG')
    .then(
      function () {
        console.log("cleared state that matches request matcher");
      },
      function (error) {
        console.log(error);
      }
    );
</script>

from mockserver import MockServerClient, HttpRequest

client = MockServerClient("localhost", 1080)
client.clear(HttpRequest(path="/some/path"), clear_type="LOG")

require 'mockserver-client'
include MockServer

client = MockServer::Client.new('localhost', 1080)
client.clear(HttpRequest.new(path: '/some/path'), type: 'LOG')

import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go"

client := mockserver.New("localhost", 1080)
err := client.Clear(
    mockserver.Request().Path("/some/path"),
    mockserver.ClearLog,
)
if err != nil {
    log.Fatal(err)
}

using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);
client.Clear(HttpRequest.Request().WithPath("/some/path"), type: "log");

use mockserver_client::{ClientBuilder, HttpRequest, ClearType};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
client.clear(
    Some(&HttpRequest::new().path("/some/path")),
    Some(ClearType::Log),
).unwrap();

use MockServer\MockServerClient;
use MockServer\HttpRequest;

$client = new MockServerClient('localhost', 1080);
$client->clear(HttpRequest::request()->path('/some/path'), 'LOG');

curl -v -X PUT "http://localhost:1080/mockserver/clear?type=log" -d '{
    "path": "/some/path"
}'

new MockServerClient("localhost", 1080).reset();

new ClientAndServer(1080).reset();

var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
  .reset()
  .then(
    function () {
      console.log("reset all state");
    },
    function (error) {
      console.log(error);
    }
  );

<script src="https://raw.githubusercontent.com/mock-server/mockserver-monorepo/master/mockserver-client-node/mockServerClient.js"></script>
<script>
  mockServerClient("localhost", 1080)
    .reset()
    .then(
      function () {
        console.log("reset all state");
      },
      function (error) {
        console.log(error);
      }
    );
</script>

from mockserver import MockServerClient

client = MockServerClient("localhost", 1080)
client.reset()

require 'mockserver-client'

client = MockServer::Client.new('localhost', 1080)
client.reset

import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go"

client := mockserver.New("localhost", 1080)
err := client.Reset()
if err != nil {
    log.Fatal(err)
}

using MockServer.Client;

using var client = new MockServerClient("localhost", 1080);
client.Reset();

use mockserver_client::ClientBuilder;

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
client.reset().unwrap();

use MockServer\MockServerClient;

$client = new MockServerClient('localhost', 1080);
$client->reset();

curl -v -X PUT "http://localhost:1080/mockserver/reset

List<Integer> boundPorts = new MockServerClient("localhost", 1080).bind(
            0
        );

List<Integer> boundPorts = new ClientAndServer(1080).bind(
            0
        );

from mockserver import MockServerClient

client = MockServerClient("localhost", 1080)
bound_ports = client.bind(0)

require 'mockserver-client'

client = MockServer::Client.new('localhost', 1080)
bound_ports = client.bind(0)

import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go"

client := mockserver.New("localhost", 1080)
boundPorts, err := client.Bind(0)
if err != nil {
    log.Fatal(err)
}

using MockServer.Client;

using var client = new MockServerClient("localhost", 1080);
var boundPorts = client.Bind(0);

use mockserver_client::ClientBuilder;

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
let bound_ports = client.bind(&[0]).unwrap();

use MockServer\MockServerClient;

$client = new MockServerClient('localhost', 1080);
$boundPorts = $client->bind(0);

curl -v -X PUT "http://localhost:1080/mockserver/bind -d '{
    "ports": [
        0,
        0
    ]
}'

List<Integer> boundPorts = new MockServerClient("localhost", 1080).bind(
            1081, 1082
        );

List<Integer> boundPorts = new ClientAndServer(1080).bind(
            1081, 1082
        );

from mockserver import MockServerClient

client = MockServerClient("localhost", 1080)
bound_ports = client.bind(1081, 1082)

require 'mockserver-client'

client = MockServer::Client.new('localhost', 1080)
bound_ports = client.bind(1081, 1082)

import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go"

client := mockserver.New("localhost", 1080)
boundPorts, err := client.Bind(1081, 1082)
if err != nil {
    log.Fatal(err)
}

using MockServer.Client;

using var client = new MockServerClient("localhost", 1080);
var boundPorts = client.Bind(1081, 1082);

use mockserver_client::ClientBuilder;

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
let bound_ports = client.bind(&[1081, 1082]).unwrap();

use MockServer\MockServerClient;

$client = new MockServerClient('localhost', 1080);
$boundPorts = $client->bind(1081, 1082);

curl -v -X PUT "http://localhost:1080/mockserver/bind -d '{
    "ports": [
        1081,
        1082
    ]
}'