MockServer supports verification of requests and responses it has received, including both proxied requests and requests that have matched an expectation.

What you can verify:

Verification can be specified as follows:

On this page:

 

How Verification Works

MockServer records all received requests in an in-memory event log (separate from application logs). Verification checks this event log:

For request matcher count verification: MockServer filters the event log to find all RECEIVED_REQUEST entries matching your request matcher, counts them, and compares the count against your constraint (atLeast(n), exactly(n), etc.). Returns HTTP 202 if the count matches, or HTTP 406 with an error message if it does not.

Verifying by disposition (forwarded vs mocked): By default a request-count verification counts every matching received request regardless of how it was handled. Use withDisposition(Disposition.FORWARDED) to count only requests that MockServer forwarded/proxied to an upstream server, or withDisposition(Disposition.MOCKED) to count only requests that matched an expectation and received a mocked response. This is useful when MockServer is acting as a proxy for some paths and a mock for others, and you want to assert that a particular request was (or was not) sent upstream. When no disposition is set the original behaviour is unchanged. (Disposition applies to request-count verification only — it is ignored for response and expectation-id verifications.)

Collecting all failures with verifyAll(...): A normal verify(...) call throws on the first verification that fails. verifyAll(...) instead evaluates every supplied verification and, if any fail, throws a single AssertionError that lists all of the failures together — so a test reports every mismatch at once instead of one per run. If all verifications pass, no error is thrown.

Waiting for asynchronous requests (Java client): A normal verify(...) checks the event log once, as a single snapshot. When your system under test sends requests asynchronously (fire-and-forget, background workers), the request may not have reached MockServer at the instant you verify. The Java client provides two timeout-aware variants so you do not need an external retry helper:

Both are implemented entirely in the Java client by polling the standard verify endpoint; no server-side wait is involved, and the existing single-snapshot verify(...) methods are unchanged.

For response verification: When a response matcher is included in the verification, MockServer retrieves all recorded request-response pairs (from EXPECTATION_RESPONSE and FORWARDED_REQUEST entries — MockServer's own auto-generated no-match responses are excluded) and filters them by the response matcher. If a request matcher is also supplied, both must match the same pair. The count of matching pairs is then checked against VerificationTimes. On failure, MockServer returns HTTP 406 with a "Response not found ..." error message listing the actual responses recorded. When detailedVerificationFailures is enabled, a field-level diff against the closest recorded response is appended to the error message.

For expectation ID verification: MockServer retrieves all events associated with the specified expectation ID (including EXPECTATION_RESPONSE and FORWARDED_REQUEST entries) and verifies the count.

For sequence verification: MockServer scans recorded requests in order, checking that each expected request appears after the previous match. This is not a simple count comparison—order matters. When httpResponses are included in a sequence verification, each step checks both the request and the response matcher against the same recorded exchange.

Important notes for parallel testing:

For more details on the internal architecture, see the Event System documentation.

 

Verification Timing

Note: MockServer processes log entries asynchronously using a ring buffer. When calling verify() immediately after sending requests, there may be a brief delay before log entries are available for verification. If verification fails unexpectedly right after requests are sent, add a small delay (e.g., 100ms) before retrying. This is most commonly needed in high-throughput scenarios or when the system under test sends requests asynchronously.

Verifying Repeating Requests

Verify that a request has been received by MockServer a specific number of times using a Verification

new MockServerClient("localhost", 1080)
    .verify(
        request()
            .withPath("/some/path"),
        VerificationTimes.atLeast(2)
    );
var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
  .verify(
    {
      'path': '/some/path'
    }, 2)
  .then(
    function () {
      console.log("request found at least 2 times");
    },
    function (error) {
      console.log(error);
    }
  );

See REST API for full JSON specification

from mockserver.client import MockServerClient
from mockserver.models import HttpRequest, VerificationTimes

client = MockServerClient("localhost", 1080)
client.verify(
    HttpRequest(path="/some/path"),
    VerificationTimes.at_least(2)
)
require 'mockserver-client'

client = MockServer::Client.new('localhost', 1080)
client.verify(
    MockServer::HttpRequest.new(path: '/some/path'),
    times: MockServer::VerificationTimes.at_least(2)
)
import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go/v7"

client := mockserver.New("localhost", 1080)
err := client.Verify(
    mockserver.Request().Path("/some/path"),
    mockserver.AtLeast(2),
)
using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);
client.Verify(
    HttpRequest.Request().WithPath("/some/path"),
    VerificationTimes.AtLeastTimes(2)
);
use mockserver_client::{ClientBuilder, HttpRequest, VerificationTimes};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
client.verify(
    HttpRequest::new().path("/some/path"),
    VerificationTimes::at_least(2),
).unwrap();
use MockServer\MockServerClient;
use MockServer\HttpRequest;
use MockServer\VerificationTimes;

$client = new MockServerClient('localhost', 1080);
$client->verify(
    HttpRequest::request()->path('/some/path'),
    VerificationTimes::atLeast(2)
);
curl -v -X PUT "http://localhost:1080/mockserver/verify" -d '{
    "httpRequest": {
        "path": "/simple"
    },
    "times": {
        "atLeast": 2
    }
}'

See REST API for full JSON specification

new MockServerClient("localhost", 1080)
.verify(
    request()
        .withPath("/some/path"),
    VerificationTimes.atMost(2)
);
var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
.verify(
{
  'path': '/some/path'
}, 0, 2)
.then(
function () {
  console.log("request found at most 2 times");
},
function (error) {
  console.log(error);
}
);

See REST API for full JSON specification

from mockserver.client import MockServerClient
from mockserver.models import HttpRequest, VerificationTimes

client = MockServerClient("localhost", 1080)
client.verify(
    HttpRequest(path="/some/path"),
    VerificationTimes.at_most(2)
)
require 'mockserver-client'

client = MockServer::Client.new('localhost', 1080)
client.verify(
    MockServer::HttpRequest.new(path: '/some/path'),
    times: MockServer::VerificationTimes.at_most(2)
)
import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go/v7"

client := mockserver.New("localhost", 1080)
err := client.Verify(
    mockserver.Request().Path("/some/path"),
    mockserver.AtMost(2),
)
using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);
client.Verify(
    HttpRequest.Request().WithPath("/some/path"),
    VerificationTimes.AtMostTimes(2)
);
use mockserver_client::{ClientBuilder, HttpRequest, VerificationTimes};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
client.verify(
    HttpRequest::new().path("/some/path"),
    VerificationTimes::at_most(2),
).unwrap();
use MockServer\MockServerClient;
use MockServer\HttpRequest;
use MockServer\VerificationTimes;

$client = new MockServerClient('localhost', 1080);
$client->verify(
    HttpRequest::request()->path('/some/path'),
    VerificationTimes::atMost(2)
);
curl -v -X PUT "http://localhost:1080/mockserver/verify" -d '{
    "httpRequest": {
        "path": "/simple"
    },
    "times": {
        "atMost": 2
    }
}'

See REST API for full JSON specification

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

See REST API for full JSON specification

from mockserver.client import MockServerClient
from mockserver.models import HttpRequest, VerificationTimes

client = MockServerClient("localhost", 1080)
client.verify(
    HttpRequest(path="/some/path"),
    VerificationTimes.exactly(2)
)
require 'mockserver-client'

client = MockServer::Client.new('localhost', 1080)
client.verify(
    MockServer::HttpRequest.new(path: '/some/path'),
    times: MockServer::VerificationTimes.exactly(2)
)
import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go/v7"

client := mockserver.New("localhost", 1080)
err := client.Verify(
    mockserver.Request().Path("/some/path"),
    mockserver.ExactlyTimes(2),
)
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
    }
}'

See REST API for full JSON specification

new MockServerClient("localhost", 1080)
    .verify(
        openAPI(
            "https://raw.githubusercontent.com/mock-server/mockserver-monorepo/master/mockserver/mockserver-integration-testing/src/main/resources/org/mockserver/openapi/openapi_petstore_example.json"
        ),
        VerificationTimes.atLeast(2)
    );
var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
    .verify(
        {
            'specUrlOrPayload': 'https://raw.githubusercontent.com/mock-server/mockserver-monorepo/master/mockserver/mockserver-integration-testing/src/main/resources/org/mockserver/openapi/openapi_petstore_example.json'
        }, 2)
    .then(
        function () {
            console.log("request found exactly 2 times");
        },
        function (error) {
            console.log(error);
        }
    );

See REST API for full JSON specification

import requests

# OpenAPI matchers are not supported in the Python client verify method;
# use the REST API directly
requests.put("http://localhost:1080/mockserver/verify", json={
    "httpRequest": {
        "specUrlOrPayload": "https://raw.githubusercontent.com/mock-server/mockserver-monorepo/master/mockserver/mockserver-integration-testing/src/main/resources/org/mockserver/openapi/openapi_petstore_example.json"
    },
    "times": {
        "atLeast": 2
    }
})
require 'net/http'
require 'json'

# OpenAPI matchers are not supported in the Ruby client verify method;
# use the REST API directly
uri = URI("http://localhost:1080/mockserver/verify")
req = Net::HTTP::Put.new(uri, 'Content-Type' => 'application/json')
req.body = JSON.generate({
    "httpRequest" => {
        "specUrlOrPayload" => "https://raw.githubusercontent.com/mock-server/mockserver-monorepo/master/mockserver/mockserver-integration-testing/src/main/resources/org/mockserver/openapi/openapi_petstore_example.json"
    },
    "times" => { "atLeast" => 2 }
})
Net::HTTP.start(uri.host, uri.port) { |http| http.request(req) }
package main

import (
    "bytes"
    "net/http"
)

func main() {
    // OpenAPI matchers are not supported in the Go client;
    // use the REST API directly
    body := []byte(`{
    "httpRequest": {
        "specUrlOrPayload": "https://raw.githubusercontent.com/mock-server/mockserver-monorepo/master/mockserver/mockserver-integration-testing/src/main/resources/org/mockserver/openapi/openapi_petstore_example.json"
    },
    "times": {
        "atLeast": 2
    }
}`)
    req, _ := http.NewRequest("PUT",
        "http://localhost:1080/mockserver/verify",
        bytes.NewReader(body))
    req.Header.Set("Content-Type", "application/json")
    http.DefaultClient.Do(req)
}
using System.Net.Http;
using System.Text;

// OpenAPI matchers are not supported in the .NET client;
// use the REST API directly
using var httpClient = new HttpClient();
var json = @"{
    ""httpRequest"": {
        ""specUrlOrPayload"": ""https://raw.githubusercontent.com/mock-server/mockserver-monorepo/master/mockserver/mockserver-integration-testing/src/main/resources/org/mockserver/openapi/openapi_petstore_example.json""
    },
    ""times"": {
        ""atLeast"": 2
    }
}";
await httpClient.PutAsync(
    "http://localhost:1080/mockserver/verify",
    new StringContent(json, Encoding.UTF8, "application/json")
);
use reqwest::blocking::Client;

// OpenAPI matchers are not supported in the Rust client;
// use the REST API directly
let client = Client::new();
let body = r#"{
    "httpRequest": {
        "specUrlOrPayload": "https://raw.githubusercontent.com/mock-server/mockserver-monorepo/master/mockserver/mockserver-integration-testing/src/main/resources/org/mockserver/openapi/openapi_petstore_example.json"
    },
    "times": {
        "atLeast": 2
    }
}"#;
client.put("http://localhost:1080/mockserver/verify")
    .header("Content-Type", "application/json")
    .body(body.to_string())
    .send()
    .unwrap();
{% raw %}
// OpenAPI matchers are not supported in the PHP client;
// use the REST API directly
$ch = curl_init('http://localhost:1080/mockserver/verify');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_POSTFIELDS => json_encode([
        'httpRequest' => [
            'specUrlOrPayload' => 'https://raw.githubusercontent.com/mock-server/mockserver-monorepo/master/mockserver/mockserver-integration-testing/src/main/resources/org/mockserver/openapi/openapi_petstore_example.json',
        ],
        'times' => ['atLeast' => 2],
    ]),
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Content-Type: application/json; charset=utf-8'],
]);
curl_exec($ch);
curl_close($ch);
{% endraw %} 
curl -v -X PUT "http://localhost:1080/mockserver/verify" -d '{
    "httpRequest": {
        "specUrlOrPayload": "https://raw.githubusercontent.com/mock-server/mockserver-monorepo/master/mockserver/mockserver-integration-testing/src/main/resources/org/mockserver/openapi/openapi_petstore_example.json"
    },
    "times": {
        "atLeast": 2
    }
}'

See REST API for full JSON specification

new MockServerClient("localhost", 1080)
    .verify(
        openAPI(
            "org/mockserver/openapi/openapi_petstore_example.json",
            "showPetById"
        ),
        VerificationTimes.once()
    );
var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
    .verify(
        {
            'specUrlOrPayload': 'org/mockserver/openapi/openapi_petstore_example.json',
            'operationId': 'showPetById'
        }, 1, 1)
    .then(
        function () {
            console.log("request found exactly 1 time");
        },
        function (error) {
            console.log(error);
        }
    );

See REST API for full JSON specification

import requests

# OpenAPI matchers are not supported in the Python client verify method;
# use the REST API directly
requests.put("http://localhost:1080/mockserver/verify", json={
    "httpRequest": {
        "specUrlOrPayload": "org/mockserver/openapi/openapi_petstore_example.json",
        "operationId": "showPetById"
    },
    "times": {
        "atLeast": 1,
        "atMost": 1
    }
})
require 'net/http'
require 'json'

# OpenAPI matchers are not supported in the Ruby client verify method;
# use the REST API directly
uri = URI("http://localhost:1080/mockserver/verify")
req = Net::HTTP::Put.new(uri, 'Content-Type' => 'application/json')
req.body = JSON.generate({
    "httpRequest" => {
        "specUrlOrPayload" => "org/mockserver/openapi/openapi_petstore_example.json",
        "operationId" => "showPetById"
    },
    "times" => { "atLeast" => 1, "atMost" => 1 }
})
Net::HTTP.start(uri.host, uri.port) { |http| http.request(req) }
package main

import (
    "bytes"
    "net/http"
)

func main() {
    // OpenAPI matchers are not supported in the Go client;
    // use the REST API directly
    body := []byte(`{
    "httpRequest": {
        "specUrlOrPayload": "org/mockserver/openapi/openapi_petstore_example.json",
        "operationId": "showPetById"
    },
    "times": {
        "atLeast": 1,
        "atMost": 1
    }
}`)
    req, _ := http.NewRequest("PUT",
        "http://localhost:1080/mockserver/verify",
        bytes.NewReader(body))
    req.Header.Set("Content-Type", "application/json")
    http.DefaultClient.Do(req)
}
using System.Net.Http;
using System.Text;

// OpenAPI matchers are not supported in the .NET client;
// use the REST API directly
using var httpClient = new HttpClient();
var json = @"{
    ""httpRequest"": {
        ""specUrlOrPayload"": ""org/mockserver/openapi/openapi_petstore_example.json"",
        ""operationId"": ""showPetById""
    },
    ""times"": {
        ""atLeast"": 1,
        ""atMost"": 1
    }
}";
await httpClient.PutAsync(
    "http://localhost:1080/mockserver/verify",
    new StringContent(json, Encoding.UTF8, "application/json")
);
use reqwest::blocking::Client;

// OpenAPI matchers are not supported in the Rust client;
// use the REST API directly
let client = Client::new();
let body = r#"{
    "httpRequest": {
        "specUrlOrPayload": "org/mockserver/openapi/openapi_petstore_example.json",
        "operationId": "showPetById"
    },
    "times": {
        "atLeast": 1,
        "atMost": 1
    }
}"#;
client.put("http://localhost:1080/mockserver/verify")
    .header("Content-Type", "application/json")
    .body(body.to_string())
    .send()
    .unwrap();
{% raw %}
// OpenAPI matchers are not supported in the PHP client;
// use the REST API directly
$ch = curl_init('http://localhost:1080/mockserver/verify');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_POSTFIELDS => json_encode([
        'httpRequest' => [
            'specUrlOrPayload' => 'org/mockserver/openapi/openapi_petstore_example.json',
            'operationId' => 'showPetById',
        ],
        'times' => ['atLeast' => 1, 'atMost' => 1],
    ]),
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Content-Type: application/json; charset=utf-8'],
]);
curl_exec($ch);
curl_close($ch);
{% endraw %} 
curl -v -X PUT "http://localhost:1080/mockserver/verify" -d '{
    "httpRequest": {
        "specUrlOrPayload": "org/mockserver/openapi/openapi_petstore_example.json",
        "operationId": "showPetById"
    },
    "times": {
        "atLeast": 1,
        "atMost": 1
    }
}'

See REST API for full JSON specification

new MockServerClient("localhost", 1080)
    .verify(
        "31e4ca35-66c6-4645-afeb-6e66c4ca0559",
        VerificationTimes.once()
    );
var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
    .verifyById(
        {
            'id': '31e4ca35-66c6-4645-afeb-6e66c4ca0559'
        }, 1, 1)
    .then(
        function () {
            console.log("request found exactly 1 time");
        },
        function (error) {
            console.log(error);
        }
    );

See REST API for full JSON specification

import requests

# verify by expectation ID is not supported in the Python client;
# use the REST API directly
requests.put("http://localhost:1080/mockserver/verify", json={
    "expectationId": {
        "id": "31e4ca35-66c6-4645-afeb-6e66c4ca0559"
    }
})
require 'net/http'
require 'json'

# verify by expectation ID is not supported in the Ruby client;
# use the REST API directly
uri = URI("http://localhost:1080/mockserver/verify")
req = Net::HTTP::Put.new(uri, 'Content-Type' => 'application/json')
req.body = JSON.generate({
    "expectationId" => {
        "id" => "31e4ca35-66c6-4645-afeb-6e66c4ca0559"
    }
})
Net::HTTP.start(uri.host, uri.port) { |http| http.request(req) }
package main

import (
    "bytes"
    "net/http"
)

func main() {
    // verify by expectation ID is not supported in the Go client;
    // use the REST API directly
    body := []byte(`{"expectationId": {"id": "31e4ca35-66c6-4645-afeb-6e66c4ca0559"}}`)
    req, _ := http.NewRequest("PUT",
        "http://localhost:1080/mockserver/verify",
        bytes.NewReader(body))
    req.Header.Set("Content-Type", "application/json")
    http.DefaultClient.Do(req)
}
using System.Net.Http;
using System.Text;

// verify by expectation ID is not supported in the .NET client;
// use the REST API directly
using var httpClient = new HttpClient();
var json = @"{""expectationId"": {""id"": ""31e4ca35-66c6-4645-afeb-6e66c4ca0559""}}";
await httpClient.PutAsync(
    "http://localhost:1080/mockserver/verify",
    new StringContent(json, Encoding.UTF8, "application/json")
);
use reqwest::blocking::Client;

// verify by expectation ID is not supported in the Rust client;
// use the REST API directly
let client = Client::new();
client.put("http://localhost:1080/mockserver/verify")
    .header("Content-Type", "application/json")
    .body(r#"{"expectationId": {"id": "31e4ca35-66c6-4645-afeb-6e66c4ca0559"}}"#.to_string())
    .send()
    .unwrap();
{% raw %}
// verify by expectation ID is not supported in the PHP client;
// use the REST API directly
$ch = curl_init('http://localhost:1080/mockserver/verify');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_POSTFIELDS => json_encode(['expectationId' => ['id' => '31e4ca35-66c6-4645-afeb-6e66c4ca0559']]),
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Content-Type: application/json; charset=utf-8'],
]);
curl_exec($ch);
curl_close($ch);
{% endraw %} 
curl -v -X PUT "http://localhost:1080/mockserver/verify" -d '{
    "expectationId": {
        "id": "31e4ca35-66c6-4645-afeb-6e66c4ca0559"
    }
}'

See REST API for full JSON specification

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

See REST API for full JSON specification

from mockserver.client import MockServerClient
from mockserver.models import HttpRequest, VerificationTimes

client = MockServerClient("localhost", 1080)
client.verify(
    HttpRequest(path="/some/path"),
    VerificationTimes.exactly(0)
)
require 'mockserver-client'

client = MockServer::Client.new('localhost', 1080)
client.verify(
    MockServer::HttpRequest.new(path: '/some/path'),
    times: MockServer::VerificationTimes.at_most(0)
)
import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go/v7"

client := mockserver.New("localhost", 1080)
err := client.Verify(
    mockserver.Request().Path("/some/path"),
    mockserver.AtMost(0),
)
using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);
client.Verify(
    HttpRequest.Request().WithPath("/some/path"),
    VerificationTimes.AtMostTimes(0)
);
use mockserver_client::{ClientBuilder, HttpRequest, VerificationTimes};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
client.verify(
    HttpRequest::new().path("/some/path"),
    VerificationTimes::exactly(0),
).unwrap();
use MockServer\MockServerClient;
use MockServer\HttpRequest;
use MockServer\VerificationTimes;

$client = new MockServerClient('localhost', 1080);
$client->verify(
    HttpRequest::request()->path('/some/path'),
    VerificationTimes::exactly(0)
);
curl -v -X PUT "http://localhost:1080/mockserver/verify" -d '{
    "httpRequest": {
        "path": "/simple"
    },
    "times": {
        "atMost": 0
    }
}'

See REST API for full JSON specification

Unlike verify requests never received above (which checks a specific request matcher was matched zero times), verifyZeroInteractions() verifies that no requests of any kind have been received by MockServer. It is equivalent to verifying a match-all request matcher with exactly(0).

new MockServerClient("localhost", 1080)
    .verifyZeroInteractions();
var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
  .verifyZeroInteractions()
  .then(
    function () {
      console.log("no requests received");
    },
    function (error) {
      console.log(error);
    }
  );

See REST API for full JSON specification

from mockserver.client import MockServerClient

client = MockServerClient("localhost", 1080)
client.verify_zero_interactions()
require 'mockserver-client'

client = MockServer::Client.new('localhost', 1080)
client.verify_zero_interactions
import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go/v7"

client := mockserver.New("localhost", 1080)
// verify that no requests were received
err := client.Verify(
    mockserver.Request(),
    mockserver.AtMost(0),
)
using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);
// verify that no requests were received
client.Verify(
    HttpRequest.Request(),
    VerificationTimes.AtMostTimes(0)
);
use mockserver_client::{ClientBuilder, HttpRequest, VerificationTimes};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
// verify that no requests were received
client.verify(
    HttpRequest::new(),
    VerificationTimes::at_most(0),
).unwrap();
use MockServer\MockServerClient;
use MockServer\HttpRequest;
use MockServer\VerificationTimes;

$client = new MockServerClient('localhost', 1080);
// verify that no requests were received
$client->verify(
    HttpRequest::request(),
    VerificationTimes::exactly(0)
);
curl -v -X PUT "http://localhost:1080/mockserver/verify" -d '{
    "httpRequest": {},
    "times": {
        "atMost": 0
    }
}'

See REST API for full JSON specification

 

Verifying Responses

MockServer can verify the responses recorded from proxied/forwarded upstream systems, or from served expectations. This is especially useful when MockServer acts as a proxy in front of a system under test (SUT) — you can assert not only that the correct requests were sent, but that the SUT returned the expected responses.

When a response matcher is supplied in a verification, MockServer switches from counting received requests to counting recorded request-response pairs whose response matches. The response matcher can match by:

If both a request matcher and a response matcher are supplied, both must match the same recorded exchange. VerificationTimes (atLeast, atMost, exactly) applies to the count of matching pairs, exactly like request verification.

REST API: PUT /mockserver/verify with body { "httpRequest": {...}, "httpResponse": {...}, "times": {...} }. Returns HTTP 202 on pass, or HTTP 406 with a "Response not found ..." error message on failure. The request matcher is optional — omit it to match responses regardless of which request produced them.

new MockServerClient("localhost", 1080)
    .verify(
        request()
            .withPath("/some/path"),
        response()
            .withStatusCode(200)
            .withBody(json("{\"status\": \"ok\"}")),
        VerificationTimes.atLeast(1)
    );
var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
  .verify(
    {
      'path': '/some/path'
    },
    {
      'statusCode': 200,
      'body': JSON.stringify({status: 'ok'})
    }, 1)
  .then(
    function () {
      console.log("matching request-response pair found at least once");
    },
    function (error) {
      console.log(error);
    }
  );

See REST API for full JSON specification

from mockserver.client import MockServerClient
from mockserver.models import HttpRequest, HttpResponse, VerificationTimes

client = MockServerClient("localhost", 1080)
client.verify(
    HttpRequest(path="/some/path"),
    HttpResponse(status_code=200, body='{"status": "ok"}'),
    VerificationTimes.at_least(1)
)
require 'mockserver-client'

client = MockServer::Client.new('localhost', 1080)
client.verify(
    MockServer::HttpRequest.new(path: '/some/path'),
    MockServer::HttpResponse.new(status_code: 200, body: '{"status": "ok"}'),
    times: MockServer::VerificationTimes.at_least(1)
)
import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go/v7"

client := mockserver.New("localhost", 1080)
err := client.Verify(
    mockserver.Request().Path("/some/path"),
    mockserver.Response().StatusCode(200).Body(`{"status": "ok"}`),
    mockserver.AtLeast(1),
)
using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);
client.Verify(
    HttpRequest.Request().WithPath("/some/path"),
    HttpResponse.Response().WithStatusCode(200).WithBody("{\"status\": \"ok\"}"),
    VerificationTimes.AtLeastTimes(1)
);
use mockserver_client::{ClientBuilder, HttpRequest, HttpResponse, VerificationTimes};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
client.verify_with_response(
    HttpRequest::new().path("/some/path"),
    HttpResponse::new().status_code(200).body(r#"{"status": "ok"}"#),
    VerificationTimes::at_least(1),
).unwrap();
use MockServer\MockServerClient;
use MockServer\HttpRequest;
use MockServer\HttpResponse;
use MockServer\VerificationTimes;

$client = new MockServerClient('localhost', 1080);
$client->verify(
    HttpRequest::request()->path('/some/path'),
    HttpResponse::response()->statusCode(200)->body('{"status": "ok"}'),
    VerificationTimes::atLeast(1)
);
curl -v -X PUT "http://localhost:1080/mockserver/verify" -d '{
    "httpRequest": {
        "path": "/some/path"
    },
    "httpResponse": {
        "statusCode": 200,
        "body": "{\"status\": \"ok\"}"
    },
    "times": {
        "atLeast": 1
    }
}'

See REST API for full JSON specification

When no request matcher is supplied, MockServer matches responses from all recorded request-response pairs. This is useful when you want to verify that a particular response was returned regardless of which request produced it.

new MockServerClient("localhost", 1080)
    .verify(
        response()
            .withStatusCode(200)
            .withHeaders(
                header("Content-Type", "application/json")
            ),
        VerificationTimes.atLeast(1)
    );
var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
  .verify(
    null,
    {
      'statusCode': 200,
      'headers': {
        'Content-Type': ['application/json']
      }
    }, 1)
  .then(
    function () {
      console.log("matching response found at least once");
    },
    function (error) {
      console.log(error);
    }
  );

See REST API for full JSON specification

from mockserver.client import MockServerClient
from mockserver.models import HttpResponse, VerificationTimes

client = MockServerClient("localhost", 1080)
client.verify(
    HttpResponse(status_code=200, headers={"Content-Type": "application/json"}),
    VerificationTimes.at_least(1)
)
require 'mockserver-client'

client = MockServer::Client.new('localhost', 1080)
client.verify(
    MockServer::HttpResponse.new(
        status_code: 200,
        headers: { 'Content-Type' => 'application/json' }
    ),
    times: MockServer::VerificationTimes.at_least(1)
)
import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go/v7"

client := mockserver.New("localhost", 1080)
err := client.VerifyResponse(
    mockserver.Response().StatusCode(200).
        Header("Content-Type", "application/json"),
    mockserver.AtLeast(1),
)
using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);
client.Verify(
    HttpResponse.Response().WithStatusCode(200)
        .WithHeader("Content-Type", "application/json"),
    VerificationTimes.AtLeastTimes(1)
);
use mockserver_client::{ClientBuilder, HttpResponse, VerificationTimes};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
client.verify_response(
    HttpResponse::new().status_code(200)
        .header("Content-Type", "application/json"),
    VerificationTimes::at_least(1),
).unwrap();
use MockServer\MockServerClient;
use MockServer\HttpResponse;
use MockServer\VerificationTimes;

$client = new MockServerClient('localhost', 1080);
$client->verify(
    HttpResponse::response()->statusCode(200)
        ->header('Content-Type', 'application/json'),
    VerificationTimes::atLeast(1)
);
curl -v -X PUT "http://localhost:1080/mockserver/verify" -d '{
    "httpResponse": {
        "statusCode": 200,
        "headers": {
            "Content-Type": ["application/json"]
        }
    },
    "times": {
        "atLeast": 1
    }
}'

See REST API for full JSON specification

Response body matchers support the same matching types as request body matchers, including JSON Schema. This example verifies that a response was recorded whose body conforms to a given JSON Schema.

new MockServerClient("localhost", 1080)
    .verify(
        request()
            .withPath("/api/users"),
        response()
            .withStatusCode(200)
            .withBody(jsonSchema("{" +
                "  \"type\": \"object\"," +
                "  \"required\": [\"id\", \"name\"]," +
                "  \"properties\": {" +
                "    \"id\": { \"type\": \"integer\" }," +
                "    \"name\": { \"type\": \"string\" }" +
                "  }" +
                "}")),
        VerificationTimes.atLeast(1)
    );
var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
  .verifyRequestAndResponse(
    {
      'path': '/api/users'
    },
    {
      'statusCode': 200,
      'body': {
        'type': 'JSON_SCHEMA',
        'jsonSchema': JSON.stringify({
          type: 'object',
          required: ['id', 'name'],
          properties: {
            id: {type: 'integer'},
            name: {type: 'string'}
          }
        })
      }
    }, 1)
  .then(
    function () {
      console.log("matching request-response pair found at least once");
    },
    function (error) {
      console.log(error);
    }
  );

See REST API for full JSON specification

from mockserver.client import MockServerClient
from mockserver.models import HttpRequest, HttpResponse, VerificationTimes

client = MockServerClient("localhost", 1080)
client.verify(
    HttpRequest(path="/api/users"),
    VerificationTimes.at_least(1),
    response=HttpResponse(
        status_code=200,
        body={
            "type": "JSON_SCHEMA",
            "jsonSchema": "{\"type\":\"object\",\"required\":[\"id\",\"name\"],\"properties\":{\"id\":{\"type\":\"integer\"},\"name\":{\"type\":\"string\"}}}"
        }
    )
)
require 'mockserver-client'

client = MockServer::Client.new('localhost', 1080)
client.verify(
    MockServer::HttpRequest.new(path: '/api/users'),
    times: MockServer::VerificationTimes.at_least(1),
    response: MockServer::HttpResponse.new(
        status_code: 200,
        body: {
            'type' => 'JSON_SCHEMA',
            'jsonSchema' => '{"type":"object","required":["id","name"],"properties":{"id":{"type":"integer"},"name":{"type":"string"}}}'
        }
    )
)
package main

import (
    "bytes"
    "net/http"
)

func main() {
    // the Go ResponseBuilder body is a plain string, so a JSON_SCHEMA
    // response-body matcher is sent via the REST API directly
    body := []byte(`{
    "httpRequest": {
        "path": "/api/users"
    },
    "httpResponse": {
        "statusCode": 200,
        "body": {
            "type": "JSON_SCHEMA",
            "jsonSchema": "{\"type\":\"object\",\"required\":[\"id\",\"name\"],\"properties\":{\"id\":{\"type\":\"integer\"},\"name\":{\"type\":\"string\"}}}"
        }
    },
    "times": {
        "atLeast": 1
    }
}`)
    req, _ := http.NewRequest("PUT",
        "http://localhost:1080/mockserver/verify",
        bytes.NewReader(body))
    req.Header.Set("Content-Type", "application/json")
    http.DefaultClient.Do(req)
}
using System.Collections.Generic;
using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);
client.Verify(
    HttpRequest.Request().WithPath("/api/users"),
    new HttpResponse
    {
        StatusCode = 200,
        Body = new Dictionary<string, object>
        {
            ["type"] = "JSON_SCHEMA",
            ["jsonSchema"] = "{\"type\":\"object\",\"required\":[\"id\",\"name\"],\"properties\":{\"id\":{\"type\":\"integer\"},\"name\":{\"type\":\"string\"}}}"
        }
    },
    VerificationTimes.AtLeastTimes(1)
);
use reqwest::blocking::Client;

// the Rust HttpResponse body is a plain string, so a JSON_SCHEMA
// response-body matcher is sent via the REST API directly
let client = Client::new();
let body = r#"{
    "httpRequest": {
        "path": "/api/users"
    },
    "httpResponse": {
        "statusCode": 200,
        "body": {
            "type": "JSON_SCHEMA",
            "jsonSchema": "{\"type\":\"object\",\"required\":[\"id\",\"name\"],\"properties\":{\"id\":{\"type\":\"integer\"},\"name\":{\"type\":\"string\"}}}"
        }
    },
    "times": {
        "atLeast": 1
    }
}"#;
client.put("http://localhost:1080/mockserver/verify")
    .header("Content-Type", "application/json")
    .body(body.to_string())
    .send()
    .unwrap();
// the PHP HttpResponse body() setter takes a string, so a JSON_SCHEMA
// response-body matcher is sent via the REST API directly
$json = json_encode([
    'httpRequest' => ['path' => '/api/users'],
    'httpResponse' => [
        'statusCode' => 200,
        'body' => [
            'type' => 'JSON_SCHEMA',
            'jsonSchema' => '{"type":"object","required":["id","name"],"properties":{"id":{"type":"integer"},"name":{"type":"string"}}}',
        ],
    ],
    'times' => ['atLeast' => 1],
]);

$ch = curl_init('http://localhost:1080/mockserver/verify');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'PUT',
    CURLOPT_POSTFIELDS     => $json,
    CURLOPT_HTTPHEADER     => ['Content-Type: application/json; charset=utf-8'],
    CURLOPT_RETURNTRANSFER => true,
]);
curl_exec($ch);
curl_close($ch);
curl -v -X PUT "http://localhost:1080/mockserver/verify" -d '{
    "httpRequest": {
        "path": "/api/users"
    },
    "httpResponse": {
        "statusCode": 200,
        "body": {
            "type": "JSON_SCHEMA",
            "jsonSchema": "{\"type\":\"object\",\"required\":[\"id\",\"name\"],\"properties\":{\"id\":{\"type\":\"integer\"},\"name\":{\"type\":\"string\"}}}"
        }
    },
    "times": {
        "atLeast": 1
    }
}'

See REST API for full JSON specification

Verifying Request Sequences

Verify that a sequence of requests has been received by MockServer in the specified order using a VerificationSequence

The each request in the sequence will be verified to have been received at least once, in the exact order specified.

new MockServerClient("localhost", 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);
    }
  );

See REST API for full JSON specification

from mockserver.client import MockServerClient
from mockserver.models import 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'

client = MockServer::Client.new('localhost', 1080)
client.verify_sequence(
    MockServer::HttpRequest.new(path: '/some/path/one'),
    MockServer::HttpRequest.new(path: '/some/path/two'),
    MockServer::HttpRequest.new(path: '/some/path/three'),
)
import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go/v7"

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"),
)
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"
      }
   ]
}'

See REST API for full JSON specification

new MockServerClient("localhost", 1080)
    .verify(
        request()
            .withPath("/status"),
        openAPI(
            "org/mockserver/openapi/openapi_petstore_example.json",
            "listPets"
        ),
        openAPI(
            "org/mockserver/openapi/openapi_petstore_example.json",
            "showPetById"
        )
    );
var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
    .verifySequence(
        {
            'path': '/status'
        },
        {
            'specUrlOrPayload': 'org/mockserver/openapi/openapi_petstore_example.json',
            'operationId': 'listPets'
        },
        {
            'specUrlOrPayload': 'org/mockserver/openapi/openapi_petstore_example.json',
            'operationId': 'showPetById'
        }
    )
    .then(
        function () {
            console.log("request sequence found in the order specified");
        },
        function (error) {
            console.log(error);
        }
    );

See REST API for full JSON specification

import requests

# OpenAPI matchers in verification sequences are not supported in the
# Python client; use the REST API directly
requests.put("http://localhost:1080/mockserver/verifySequence", json={
    "httpRequests": [
        {"path": "/status"},
        {
            "specUrlOrPayload": "org/mockserver/openapi/openapi_petstore_example.json",
            "operationId": "listPets"
        },
        {
            "specUrlOrPayload": "org/mockserver/openapi/openapi_petstore_example.json",
            "operationId": "showPetById"
        }
    ]
})
require 'net/http'
require 'json'

# OpenAPI matchers in verification sequences are not supported in the
# Ruby client; use the REST API directly
uri = URI("http://localhost:1080/mockserver/verifySequence")
req = Net::HTTP::Put.new(uri, 'Content-Type' => 'application/json')
req.body = JSON.generate({
    "httpRequests" => [
        { "path" => "/status" },
        {
            "specUrlOrPayload" => "org/mockserver/openapi/openapi_petstore_example.json",
            "operationId" => "listPets"
        },
        {
            "specUrlOrPayload" => "org/mockserver/openapi/openapi_petstore_example.json",
            "operationId" => "showPetById"
        }
    ]
})
Net::HTTP.start(uri.host, uri.port) { |http| http.request(req) }
package main

import (
    "bytes"
    "net/http"
)

func main() {
    // OpenAPI matchers are not supported in the Go client;
    // use the REST API directly
    body := []byte(`{
   "httpRequests":[
      {"path": "/status"},
      {
         "specUrlOrPayload": "org/mockserver/openapi/openapi_petstore_example.json",
         "operationId": "listPets"
      },
      {
         "specUrlOrPayload": "org/mockserver/openapi/openapi_petstore_example.json",
         "operationId": "showPetById"
      }
   ]
}`)
    req, _ := http.NewRequest("PUT",
        "http://localhost:1080/mockserver/verifySequence",
        bytes.NewReader(body))
    req.Header.Set("Content-Type", "application/json")
    http.DefaultClient.Do(req)
}
using System.Net.Http;
using System.Text;

// OpenAPI matchers are not supported in the .NET client;
// use the REST API directly
using var httpClient = new HttpClient();
var json = @"{
   ""httpRequests"":[
      {""path"": ""/status""},
      {
         ""specUrlOrPayload"": ""org/mockserver/openapi/openapi_petstore_example.json"",
         ""operationId"": ""listPets""
      },
      {
         ""specUrlOrPayload"": ""org/mockserver/openapi/openapi_petstore_example.json"",
         ""operationId"": ""showPetById""
      }
   ]
}";
await httpClient.PutAsync(
    "http://localhost:1080/mockserver/verifySequence",
    new StringContent(json, Encoding.UTF8, "application/json")
);
use reqwest::blocking::Client;

// OpenAPI matchers are not supported in the Rust client;
// use the REST API directly
let client = Client::new();
let body = r#"{
   "httpRequests":[
      {"path": "/status"},
      {
         "specUrlOrPayload": "org/mockserver/openapi/openapi_petstore_example.json",
         "operationId": "listPets"
      },
      {
         "specUrlOrPayload": "org/mockserver/openapi/openapi_petstore_example.json",
         "operationId": "showPetById"
      }
   ]
}"#;
client.put("http://localhost:1080/mockserver/verifySequence")
    .header("Content-Type", "application/json")
    .body(body.to_string())
    .send()
    .unwrap();
{% raw %}
// OpenAPI matchers in verification sequences are not supported in the
// PHP client; use the REST API directly
$ch = curl_init('http://localhost:1080/mockserver/verifySequence');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_POSTFIELDS => json_encode([
        'httpRequests' => [
            ['path' => '/status'],
            [
                'specUrlOrPayload' => 'org/mockserver/openapi/openapi_petstore_example.json',
                'operationId' => 'listPets',
            ],
            [
                'specUrlOrPayload' => 'org/mockserver/openapi/openapi_petstore_example.json',
                'operationId' => 'showPetById',
            ],
        ],
    ]),
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Content-Type: application/json; charset=utf-8'],
]);
curl_exec($ch);
curl_close($ch);
{% endraw %} 
curl -v -X PUT "http://localhost:1080/mockserver/verifySequence" -d '{
   "httpRequests":[
      {
         "path": "/status"
      },
      {
         "specUrlOrPayload": "org/mockserver/openapi/openapi_petstore_example.json",
         "operationId": "listPets"
      },
      {
         "specUrlOrPayload": "org/mockserver/openapi/openapi_petstore_example.json",
         "operationId": "showPetById"
      }
   ]
}'

See REST API for full JSON specification

new MockServerClient("localhost", 1080)
    .verify(
        "31e4ca35-66c6-4645-afeb-6e66c4ca0559",
        "66c6ca35-ca35-66f5-8feb-5e6ac7ca0559",
        "ca3531e4-23c8-ff45-88f5-4ca0c7ca0559"
    );
var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
    .verifySequenceById(
        {
            'id': '31e4ca35-66c6-4645-afeb-6e66c4ca0559'
        },
        {
            'id': '66c6ca35-ca35-66f5-8feb-5e6ac7ca0559'
        },
        {
            'id': 'ca3531e4-23c8-ff45-88f5-4ca0c7ca0559'
        }
    )
    .then(
        function () {
            console.log("request sequence found in the order specified");
        },
        function (error) {
            console.log(error);
        }
    );

See REST API for full JSON specification

import requests

# verify sequence by expectation IDs is not supported in the Python
# client; use the REST API directly
requests.put("http://localhost:1080/mockserver/verifySequence", json={
    "expectationIds": [
        {"id": "31e4ca35-66c6-4645-afeb-6e66c4ca0559"},
        {"id": "66c6ca35-ca35-66f5-8feb-5e6ac7ca0559"},
        {"id": "ca3531e4-23c8-ff45-88f5-4ca0c7ca0559"}
    ]
})
require 'net/http'
require 'json'

# verify sequence by expectation IDs is not supported in the Ruby
# client; use the REST API directly
uri = URI("http://localhost:1080/mockserver/verifySequence")
req = Net::HTTP::Put.new(uri, 'Content-Type' => 'application/json')
req.body = JSON.generate({
    "expectationIds" => [
        { "id" => "31e4ca35-66c6-4645-afeb-6e66c4ca0559" },
        { "id" => "66c6ca35-ca35-66f5-8feb-5e6ac7ca0559" },
        { "id" => "ca3531e4-23c8-ff45-88f5-4ca0c7ca0559" }
    ]
})
Net::HTTP.start(uri.host, uri.port) { |http| http.request(req) }
package main

import (
    "bytes"
    "net/http"
)

func main() {
    // verify sequence by expectation IDs is not supported in the Go
    // client; use the REST API directly
    body := []byte(`{
    "expectationIds": [
        {"id": "31e4ca35-66c6-4645-afeb-6e66c4ca0559"},
        {"id": "66c6ca35-ca35-66f5-8feb-5e6ac7ca0559"},
        {"id": "ca3531e4-23c8-ff45-88f5-4ca0c7ca0559"}
    ]
}`)
    req, _ := http.NewRequest("PUT",
        "http://localhost:1080/mockserver/verifySequence",
        bytes.NewReader(body))
    req.Header.Set("Content-Type", "application/json")
    http.DefaultClient.Do(req)
}
using System.Net.Http;
using System.Text;

// verify sequence by expectation IDs is not supported in the .NET
// client; use the REST API directly
using var httpClient = new HttpClient();
var json = @"{
    ""expectationIds"": [
        {""id"": ""31e4ca35-66c6-4645-afeb-6e66c4ca0559""},
        {""id"": ""66c6ca35-ca35-66f5-8feb-5e6ac7ca0559""},
        {""id"": ""ca3531e4-23c8-ff45-88f5-4ca0c7ca0559""}
    ]
}";
await httpClient.PutAsync(
    "http://localhost:1080/mockserver/verifySequence",
    new StringContent(json, Encoding.UTF8, "application/json")
);
use reqwest::blocking::Client;

// verify sequence by expectation IDs is not supported in the Rust
// client; use the REST API directly
let client = Client::new();
let body = r#"{
    "expectationIds": [
        {"id": "31e4ca35-66c6-4645-afeb-6e66c4ca0559"},
        {"id": "66c6ca35-ca35-66f5-8feb-5e6ac7ca0559"},
        {"id": "ca3531e4-23c8-ff45-88f5-4ca0c7ca0559"}
    ]
}"#;
client.put("http://localhost:1080/mockserver/verifySequence")
    .header("Content-Type", "application/json")
    .body(body.to_string())
    .send()
    .unwrap();
{% raw %}
// verify sequence by expectation IDs is not supported in the PHP
// client; use the REST API directly
$ch = curl_init('http://localhost:1080/mockserver/verifySequence');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_POSTFIELDS => json_encode([
        'expectationIds' => [
            ['id' => '31e4ca35-66c6-4645-afeb-6e66c4ca0559'],
            ['id' => '66c6ca35-ca35-66f5-8feb-5e6ac7ca0559'],
            ['id' => 'ca3531e4-23c8-ff45-88f5-4ca0c7ca0559'],
        ],
    ]),
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Content-Type: application/json; charset=utf-8'],
]);
curl_exec($ch);
curl_close($ch);
{% endraw %} 
curl -v -X PUT "http://localhost:1080/mockserver/verifySequence" -d '{
    "expectationIds": [
        {
            "id": "31e4ca35-66c6-4645-afeb-6e66c4ca0559"
        },
        {
            "id": "66c6ca35-ca35-66f5-8feb-5e6ac7ca0559"
        },
        {
            "id": "ca3531e4-23c8-ff45-88f5-4ca0c7ca0559"
        }
    ]
}'

See REST API for full JSON specification

You can verify that a sequence of request-response pairs was recorded in order. Each step in the sequence can include a request matcher, a response matcher, or both. The httpRequests and httpResponses arrays are matched by index — httpRequests[0] is paired with httpResponses[0], and so on. Either array element can be omitted (or null) to act as a wildcard for that side of the pair.

new MockServerClient("localhost", 1080)
    .verify(
        verificationSequence()
            .withRequests(
                request().withPath("/api/login"),
                request().withPath("/api/data")
            )
            .withResponses(
                response().withStatusCode(200),
                response().withStatusCode(200)
                    .withBody(json("{\"result\": \"success\"}"))
            )
    );
var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080)
    .verifySequence(
        {
            httpRequests: [
                { 'path': '/api/login' },
                { 'path': '/api/data' }
            ],
            httpResponses: [
                { 'statusCode': 200 },
                { 'statusCode': 200, 'body': JSON.stringify({result: 'success'}) }
            ]
        }
    )
    .then(
        function () {
            console.log("request-response sequence found in the order specified");
        },
        function (error) {
            console.log(error);
        }
    );

See REST API for full JSON specification

from mockserver.client import MockServerClient
from mockserver.models import HttpRequest, HttpResponse

client = MockServerClient("localhost", 1080)
client.verify_sequence(
    requests=[
        HttpRequest(path="/api/login"),
        HttpRequest(path="/api/data"),
    ],
    responses=[
        HttpResponse(status_code=200),
        HttpResponse(status_code=200, body='{"result": "success"}'),
    ]
)
require 'mockserver-client'

client = MockServer::Client.new('localhost', 1080)
client.verify_sequence(
    requests: [
        MockServer::HttpRequest.new(path: '/api/login'),
        MockServer::HttpRequest.new(path: '/api/data'),
    ],
    responses: [
        MockServer::HttpResponse.new(status_code: 200),
        MockServer::HttpResponse.new(status_code: 200, body: '{"result": "success"}'),
    ]
)
import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go/v7"

client := mockserver.New("localhost", 1080)
err := client.VerifySequenceWithResponses(
    []mockserver.RequestDefinition{
        mockserver.Request().Path("/api/login"),
        mockserver.Request().Path("/api/data"),
    },
    []mockserver.HttpResponse{
        mockserver.Response().StatusCode(200),
        mockserver.Response().StatusCode(200).Body(`{"result": "success"}`),
    },
)
using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);
client.VerifySequence(
    new[] {
        HttpRequest.Request().WithPath("/api/login"),
        HttpRequest.Request().WithPath("/api/data")
    },
    new[] {
        HttpResponse.Response().WithStatusCode(200),
        HttpResponse.Response().WithStatusCode(200).WithBody("{\"result\": \"success\"}")
    }
);
use mockserver_client::{ClientBuilder, HttpRequest, HttpResponse};

let client = ClientBuilder::new("localhost", 1080).build().unwrap();
client.verify_sequence_with_responses(
    vec![
        HttpRequest::new().path("/api/login"),
        HttpRequest::new().path("/api/data"),
    ],
    vec![
        HttpResponse::new().status_code(200),
        HttpResponse::new().status_code(200).body(r#"{"result": "success"}"#),
    ],
).unwrap();
{% raw %}
use MockServer\MockServerClient;
use MockServer\HttpRequest;
use MockServer\HttpResponse;

$client = new MockServerClient('localhost', 1080);
$client->verifySequence(
    [
        HttpRequest::request()->path('/api/login'),
        HttpRequest::request()->path('/api/data'),
    ],
    [
        HttpResponse::response()->statusCode(200),
        HttpResponse::response()->statusCode(200)->body('{"result": "success"}'),
    ]
);
{% endraw %} 
curl -v -X PUT "http://localhost:1080/mockserver/verifySequence" -d '{
    "httpRequests": [
        {
            "path": "/api/login"
        },
        {
            "path": "/api/data"
        }
    ],
    "httpResponses": [
        {
            "statusCode": 200
        },
        {
            "statusCode": 200,
            "body": "{\"result\": \"success\"}"
        }
    ]
}'

See REST API for full JSON specification