WireMock

https://wiremock.org/docs/
Admin
WireMock is a popular open-source tool for API mock testing that helps developers create stable test...
Tokens:106,789
Snippets:1,175
Trust Score:9.5
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install WireMock CLI

Source: https://wiremock.org/docs/solutions/ai

Global installation of the WireMock CLI tool via npm.

```bash
npm i -g @wiremock/cli
```

--------------------------------

### Install and Authenticate WireMock CLI

Source: https://wiremock.org/docs/solutions/service-virtualization

Install the global CLI package and authenticate the session to manage mock APIs from the terminal.

```bash
npm i -g @wiremock/cli
wiremock login
```

--------------------------------

### Install Agent Skills

Source: https://wiremock.org/docs/solutions/ai

Commands to install the WireMock agent skills marketplace and specific skill package.

```bash
claude plugin marketplace add wiremock-inc/skills
claude plugin install wiremock-cloud@wiremock-inc-skills
```

```bash
/plugin marketplace add wiremock-inc/skills
/plugin install wiremock-cloud@wiremock-inc-skills
```

--------------------------------

### POST /__admin/recordings/start

Source: https://wiremock.org/docs/record-playback

Starts the recording of requests based on the provided specification.

```APIDOC
## POST /__admin/recordings/start

### Description
Starts a recording session with specific filters, header capture rules, and body extraction criteria.

### Method
POST

### Endpoint
/__admin/recordings/start

### Request Body
- **targetBaseUrl** (string) - Optional - The base URL of the target service to proxy requests to.
- **filters** (object) - Optional - Criteria for matching requests to be recorded.
- **captureHeaders** (object) - Optional - Map of header names to match parameters.
- **requestBodyPattern** (object) - Optional - Pattern to match request bodies.
- **extractBodyCriteria** (object) - Optional - Thresholds for extracting bodies to files.
- **persist** (boolean) - Optional - Whether to make stubs persistent.
- **repeatsAsScenarios** (boolean) - Optional - Whether to treat repeated requests as scenarios.
- **transformers** (array) - Optional - List of response transformers.
- **transformerParameters** (object) - Optional - Parameters for the transformers.

### Request Example
{
  "targetBaseUrl" : "http://examples.wiremockapi.cloud/",
  "filters" : {
    "urlPathPattern" : "/api/.*",
    "method" : "GET",
    "allowNonProxied": true
  },
  "captureHeaders" : {
    "Accept" : { },
    "Content-Type" : {
      "caseInsensitive" : true
    }
  },
  "requestBodyPattern" : {
    "matcher" : "equalToJson",
    "ignoreArrayOrder" : false,
    "ignoreExtraElements" : true
  },
  "extractBodyCriteria" : {
    "textSizeThreshold" : "2048",
    "binarySizeThreshold" : "10240"
  },
  "persist" : false,
  "repeatsAsScenarios" : false,
  "transformers" : [ "modify-response-header" ],
  "transformerParameters" : {
    "headerValue" : "123"
  }
}
```

--------------------------------

### Get all scenarios response

Source: https://wiremock.org/docs/standalone/admin-api-reference

Example JSON response structure for the GET /__admin/scenarios endpoint.

```json
{
  "scenarios": [
    {
      "id": "c8d249ec-d86d-48b1-88a8-a660e6848042",
      "name": "my_scenario",
      "possibleStates": [
        "Started",
        "state_1",
        "state_2"
],
      "state": "state_2"
}
]

}
```

--------------------------------

### Initialize WireMockServer with WebSocket settings

Source: https://wiremock.org/docs/configuration

Example of configuring a WireMockServer instance with custom WebSocket settings.

```java
WireMockServer wm = new WireMockServer(
    wireMockConfig()
        .port(8080)
        .webSocketIdleTimeout(600000)         // 10 minute idle timeout
        .webSocketMaxTextMessageSize(2097152)  // 2MB max text message
        .webSocketMaxBinaryMessageSize(5242880)); // 5MB max binary message
```

--------------------------------

### Start with command line arguments

Source: https://wiremock.org/docs/standalone/docker

Passes configuration parameters directly to the WireMock process inside the container.

```bash
docker run -it --rm \
-p 8443:8443 \
--name wiremock \
wiremock/wiremock:3.13.2 \
--https-port 8443 --verbose
```

--------------------------------

### Get all file names response

Source: https://wiremock.org/docs/standalone/admin-api-reference

Example JSON response structure for the GET /__admin/files endpoint.

```json
[
  "file1.json",
  "file2.json",
  "file3.txt"

]
```

--------------------------------

### POST /__admin/recordings/start

Source: https://wiremock.org/docs/record-playback

Starts a recording session to capture traffic from the specified target base URL.

```APIDOC
## POST /__admin/recordings/start

### Description
Starts a recording session to capture traffic from the specified target base URL.

### Method
POST

### Endpoint
/__admin/recordings/start

### Request Body
- **targetBaseUrl** (string) - Required - The base URL of the external API to record.

### Request Example
{
  "targetBaseUrl": "http://examples.wiremockapi.cloud/"
}
```

--------------------------------

### Example XML Requests for Order Matching

Source: https://wiremock.org/docs/request-matching

Example XML payloads that match the stub when ignoreOrderOfSameNode is enabled.

```xml
<body>
    <entry>2</entry>
    <entry>1</entry>
</body>
```

```xml
<body>
    <entry>1</entry>
    <entry>2</entry>
</body>
```

--------------------------------

### Defining directory structure for classpath resources

Source: https://wiremock.org/docs/standalone/java-jar

Example directory layout required for packaging stubs into a standalone JAR.

```text
src/main/resources
src/main/resources/wiremock-stuff
src/main/resources/wiremock-stuff/__files
src/main/resources/wiremock-stuff/mappings
```

--------------------------------

### Start a single WireMock container

Source: https://wiremock.org/docs/standalone/docker

Launches a WireMock container with default settings on port 8080.

```bash
docker run -it --rm \
-p 8080:8080 \
--name wiremock \
wiremock/wiremock:3.13.2
```

--------------------------------

### Install WireMock Claude Code Skill

Source: https://wiremock.org/docs/solutions/service-virtualization

Add and install the WireMock Cloud skill for the Claude Code agent.

```bash
claude plugin marketplace add wiremock-inc/skills
claude plugin install wiremock-cloud@wiremock-inc-skills
```

--------------------------------

### Implement a mock server with wiremock-rs

Source: https://wiremock.org/docs/solutions/rust

Starts a background HTTP server and mounts a mock response for a specific path and method.

```rust
use wiremock::{MockServer, Mock, ResponseTemplate};
use wiremock::matchers::{method, path};


#[async_std::main]
async fn main() {
    // Start a background HTTP server on a random local port
    let mock_server = MockServer::start().await;


    // Arrange the behaviour of the MockServer adding a Mock:
    // when it receives a GET request on '/hello' it will respond with a 200.
    Mock::given(method("GET")).and(path("/hello"))
        .respond_with(ResponseTemplate::new(200))
        .mount(&mock_server).await;


    // Verify the response
    let status = surf::get(format!("{}/hello", &mock_server.uri()))
        .await.unwrap().status();
    assert_eq!(status.as_u16(), 200);
}
```

--------------------------------

### Example output of random helper

Source: https://wiremock.org/docs/faker-extension

Shows the resulting JSON output generated by the random helper.

```json
{
  "firstName": "John",
  "lastName": "Smith",
  "email": "john.smith@example.com"
}
```

--------------------------------

### Start WireMock Standalone

Source: https://wiremock.org/docs/solutions/service-virtualization

Run WireMock as a persistent process using the standalone JAR file.

```bash
java -jar wiremock-standalone-3.13.2.jar --port 8080 --root-dir ./service-mocks
```

--------------------------------

### Run WireMock standalone with gRPC extension

Source: https://wiremock.org/docs/grpc

Starts the WireMock server with the standalone JAR and the gRPC extension JAR on the classpath.

```bash
java -cp wiremock-standalone-3.13.2.jar:wiremock-grpc-extension-standalone-0.11.0.jar \
wiremock.Run \
--root-dir wiremock
```

--------------------------------

### GET /__admin/version

Source: https://wiremock.org/docs/standalone/admin-api-reference

Returns the current version of the WireMock server.

```APIDOC
## GET /__admin/version

### Description
Returns the version of the WireMock server.

### Method
GET

### Endpoint
/__admin/version

### Response
#### Success Response (200)
- **version** (string) - The version of the server

#### Response Example
{
  "version": "3.8.0"
}
```

--------------------------------

### Version response sample

Source: https://wiremock.org/docs/standalone/admin-api-reference

Example JSON response containing the current WireMock server version.

```json
{
  * "version": "3.8.0"

}
```

--------------------------------

### Configure Multi-domain Mocking with WireMockServer

Source: https://wiremock.org/docs/multi-domain-mocking

Demonstrates manual setup of WireMockServer with browser proxying and JvmProxyConfigurer for general Java applications.

```java
public void testViaProxyUsingServer() throws Exception {
  WireMockServer wireMockServer = new WireMockServer(options()
    .dynamicPort()
    .enableBrowserProxying(true)
  );
  wireMockServer.start();


  HttpClient httpClient = HttpClientBuilder.create()
    .useSystemProperties() // This must be enabled for auto proxy config
    .build();


  JvmProxyConfigurer.configureFor(wireMockServer);


  wireMockServer.stubFor(get("/things")
    .withHost(equalTo("my.first.domain"))
    .willReturn(ok("Domain 1")));


  wireMockServer.stubFor(get("/things")
    .withHost(equalTo("my.second.domain"))
    .willReturn(ok("Domain 2")));


  HttpResponse response = httpClient.execute(new HttpGet("http://my.first.domain/things"));
  String responseBody = EntityUtils.toString(response.getEntity()); // Should == Domain 1


  response = httpClient.execute(new HttpGet("http://my.second.domain/things"));
  responseBody = EntityUtils.toString(response.getEntity()); // Should == Domain 2


  wireMockServer.stop();
  JvmProxyConfigurer.restorePrevious();
}
```

--------------------------------

### Start WireMock as a browser proxy

Source: https://wiremock.org/docs/proxying

Launch the standalone WireMock server with browser proxying enabled on a specific port.

```bash
$ java -jar wiremock-standalone-3.13.2.jar --enable-browser-proxying --port 9999
```

--------------------------------

### Define and Manage Stubs with Metadata

Source: https://wiremock.org/docs/messaging/stubbing

Examples for creating stubs with metadata and performing lookups or removals based on that metadata.

```java
import static com.github.tomakehurst.wiremock.common.Metadata.metadata;


messageStubFor(
    message()
        .withName("Categorized stub")
        .withMetadata(metadata()
            .attr("category", "important")
            .attr("version", "2"))
        .willTriggerActions(
            sendMessage("response").onOriginatingChannel()));


// Find stubs by metadata
List<MessageStubMapping> found = findMessageStubsByMetadata(
    matchingJsonPath("$.category", equalTo("important")));


// Remove stubs by metadata
removeMessageStubsByMetadata(
    equalToJson("{ \"category\": \"test\" }"));
```

```json
{
  "name": "Categorized stub",
  "metadata": {
    "category": "important",
    "version": "2"
  },
  "trigger": {
    "type": "message"
  },
  "actions": [
    {
      "type": "send",
      "channelTarget": { "type": "originating" },
      "message": { "body": { "data": "response" } }
    }
  ]
}
```

--------------------------------

### GET /__admin/scenarios

Source: https://wiremock.org/docs/stateful-behaviour

Fetches the names, current state, and possible states of all scenarios.

```APIDOC
## GET /__admin/scenarios

### Description
Fetches the names, current state, and possible states of all scenarios.

### Method
GET

### Endpoint
/__admin/scenarios

### Response
#### Success Response (200)
- **scenarios** (array) - List of scenario objects containing id, name, state, and possibleStates.
```

--------------------------------

### Request response sample

Source: https://wiremock.org/docs/standalone/admin-api-reference

Example JSON response structure for a request retrieval operation.

```json
{
  "id": "12fb14bb-600e-4bfa-bd8d-be7f12562c99",
  "request": {
    "url": "/received-request/2",
    "absoluteUrl": "http://localhost:56738/received-request/2",
    "method": "GET",
    "clientIp": "127.0.0.1",
    "headers": {
      "Connection": "keep-alive",
      "Host": "localhost:56738",
      "User-Agent": "Apache-HttpClient/4.5.1 (Java/1.7.0_51)"
},
    "cookies": { },
    "browserProxyRequest": false,
    "loggedDate": 1471442557047,
    "bodyAsBase64": "",
    "body": "",
    "loggedDateString": "2016-08-17T14:02:37Z"
},
  "responseDefinition": {
    "status": 404,
    "transformers": [ ],
    "fromConfiguredStub": false,
    "transformerParameters": { }
}

}
```

--------------------------------

### Implement GlobalSettingsListener in an extension

Source: https://wiremock.org/docs/extensibility/listening-for-settings-changes

This example demonstrates implementing GlobalSettingsListener alongside ServeEventListener to capture and use extended settings values.

```java
public class MyConfigurableServeEventListener
        implements ServeEventListener, GlobalSettingsListener {


    private volatile String mySetting = "";


    @Override
    public void afterGlobalSettingsUpdated(
            GlobalSettings oldSettings,
            GlobalSettings newSettings) {


        mySetting = newSettings.getExtended().getString("my-setting");
    }


    @Override
    public void onEvent(
            RequestPhase requestPhase,
            ServeEvent serveEvent,
            Parameters parameters) {


        log.debug("My setting is " + mySetting);
    }


    @Override
    public String getName() {
        return "my-listener";
    }
}
```

--------------------------------

### Initialize WireMock Container in C

Source: https://wiremock.org/docs/solutions/c_cpp

Demonstrates how to create a WireMock container, configure mappings, and handle container execution errors.

```c
#include <stdio.h>
#include <string.h>
#include "testcontainers-c-wiremock.h"


int main() {
    printf("Creating new container: %s\n", DEFAULT_WIREMOCK_IMAGE);
    int requestId = tc_wm_new_default_container();
    tc_wm_with_mapping(requestId, "test_data/hello.json", "hello");
    tc_with_file(requestId, "test_data/hello.json", "/home/wiremock/mappings/hello2.json");
    struct tc_run_container_return ret = tc_run_container(requestId);
    int containerId = ret.r0;
    if (!ret.r1) {
        printf("Failed to run the container: %s\n", ret.r2);
        if (containerId != -1) { // Print container log
            char* log = tc_get_container_log(containerId);
            if (log != NULL) {
                printf("\n%s\n", log);
            }
        }
        return -1;
    }


    // ...
```

--------------------------------

### Start Recording via Admin API

Source: https://wiremock.org/docs/record-playback

Configures recording parameters via the WireMock Admin API using a JSON request body.

```json
POST /__admin/recordings/start
{
  "targetBaseUrl" : "http://examples.wiremockapi.cloud/",
  "filters" : {
    "urlPathPattern" : "/api/.*",
    "method" : "GET",
    "allowNonProxied": true
  },
  "captureHeaders" : {
    "Accept" : { },
    "Content-Type" : {
      "caseInsensitive" : true
    }
  },
  "requestBodyPattern" : {
    "matcher" : "equalToJson",
    "ignoreArrayOrder" : false,
    "ignoreExtraElements" : true
  },
  "extractBodyCriteria" : {
    "textSizeThreshold" : "2048",
    "binarySizeThreshold" : "10240"
  },
  "persist" : false,
  "repeatsAsScenarios" : false,
  "transformers" : [ "modify-response-header" ],
  "transformerParameters" : {
    "headerValue" : "123"
  }
}
```

--------------------------------

### Start and Stop Recording via JSON API

Source: https://wiremock.org/docs/record-playback

Endpoints for controlling the recording state via HTTP requests.

```http
POST /__admin/recordings/start
{
  "targetBaseUrl": "http://examples.wiremockapi.cloud/"
}
```

```http
POST /__admin/recordings/stop
```

--------------------------------

### Install Faker Extension via Maven or Gradle

Source: https://wiremock.org/docs/faker-extension

Add the extension dependency to your project build configuration.

```xml
<dependency>
    <groupId>org.wiremock.extensions</groupId>
    <artifactId>wiremock-faker-extension</artifactId>
    <version>0.2.0</version>
</dependency>
```

```groovy
dependencies {
    implementation 'org.wiremock.extensions:wiremock-faker-extension-standalone:0.2.0'
}
```

--------------------------------

### Get all stub mappings response structure

Source: https://wiremock.org/docs/standalone/admin-api-reference

Example JSON response returned by the GET /__admin/mappings endpoint, containing a list of stub mappings and metadata.

```json
{
  "meta": {
    "total": 2
},
  "mappings": [
    {
      "id": "76ada7b0-49ae-4229-91c4-396a36f18e09",
      "uuid": "76ada7b0-49ae-4229-91c4-396a36f18e09",
      "request": {
        "method": "GET",
        "url": "/search?q=things",
        "headers": {
          "Accept": {
            "equalTo": "application/json"
}
}
},
      "response": {
        "status": 200,
        "jsonBody": [
          "thing1",
          "thing2"
],
        "headers": {
          "Content-Type": "application/json"
}
}
},
    {
      "request": {
        "method": "POST",
        "urlPath": "/some/things",
        "bodyPatterns": [
          {
            "equalToXml": "<stuff />"
}
]
},
      "response": {
        "status": 201
}
}
]

}
```

--------------------------------

### Write a WireMock Test Case

Source: https://wiremock.org/docs/quickstart/java-junit

Example of stubbing a POST request and verifying the response using Java 11+ HttpClient and AssertJ.

```java
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;


...


@Test
public void exampleTest() {
    // Setup the WireMock mapping stub for the test
    stubFor(post("/my/resource")
        .withHeader("Content-Type", containing("xml"))
        .willReturn(ok()
            .withHeader("Content-Type", "text/xml")
            .withBody("<response>SUCCESS</response>")));


    // Setup HTTP POST request (with HTTP Client embedded in Java 11+)
    final HttpClient client = HttpClient.newBuilder().build();
    final HttpRequest request = HttpRequest.newBuilder()
        .uri(wiremockServer.url("/my/resource"))
        .header("Content-Type", "text/xml")
        .POST().build();


    // Send the request and receive the response
    final HttpResponse<String> response =
            client.send(request, HttpResponse.BodyHandlers.ofString());


    // Verify the response (with AssertJ)
    assertThat(response.statusCode()).as("Wrong response status code").isEqualTo(200);
    assertThat(response.body()).as("Wrong response body").contains("<response>SUCCESS</response>");
}
```

--------------------------------

### Retrieve near-misses JSON response

Source: https://wiremock.org/docs/standalone/admin-api-reference

Example JSON response structure for the GET /__admin/requests/unmatched/near-misses endpoint.

```json
{
  "nearMisses": [
    {
      "request": {
        "url": "/nomatch",
        "absoluteUrl": "http://localhost:8080/nomatch",
        "method": "GET",
        "clientIp": "0:0:0:0:0:0:0:1",
        "headers": {
          "User-Agent": "curl/7.30.0",
          "Accept": "*/*",
          "Host": "localhost:8080"
},
        "cookies": { },
        "browserProxyRequest": false,
        "loggedDate": 1467402464520,
        "bodyAsBase64": "",
        "body": "",
        "loggedDateString": "2016-07-01T19:47:44Z"
},
      "requestPattern": {
        "url": "/almostmatch",
        "method": "GET"
},
      "matchResult": {
        "distance": 0.06944444444444445
}
}
]

}
```

--------------------------------

### Start and Stop Recording via Java DSL

Source: https://wiremock.org/docs/record-playback

Demonstrates recording traffic using the static DSL, client instance, or direct server instance.

```java
// Static DSL
WireMock.startRecording("http://examples.wiremockapi.cloud/");
List<StubMapping> recordedMappings = WireMock.stopRecording();


// Client instance
WireMock wireMockClient = new WireMock(8080);
wireMockClient.startStubRecording("http://examples.wiremockapi.cloud/");
List<StubMapping> recordedMappings = wireMockClient.stopStubRecording();


// Directly
WireMockServer wireMockServer = new WireMockServer();
wireMockServer.start();
wireMockServer.startRecording("http://examples.wiremockapi.cloud/");
List<StubMapping> recordedMappings = wireMockServer.stopRecording();
```

--------------------------------

### Retrieve unmatched requests JSON response

Source: https://wiremock.org/docs/standalone/admin-api-reference

Example JSON response structure for the GET /__admin/requests/unmatched endpoint.

```json
{
  "requests": [
    {
      "url": "/my/url",
      "absoluteUrl": "http://mydomain.com/my/url",
      "method": "GET",
      "headers": {
        "Accept-Language": "en-us,en;q=0.5",
        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.6; rv:9.0) Gecko/20100101 Firefox/9.0",
        "Accept": "image/png,image/*;q=0.8,*/*;q=0.5"
},
      "body": "",
      "browserProxyRequest": true,
      "loggedDate": 1339083581823,
      "loggedDateString": "2012-06-07 16:39:41"
},
    {
      "url": "/my/other/url",
      "absoluteUrl": "http://my.other.domain.com/my/other/url",
      "method": "POST",
      "headers": {
        "Accept": "text/plain",
        "Content-Type": "text/plain"
},
      "body": "My text",
      "browserProxyRequest": false,
      "loggedDate": 1339083581823,
      "loggedDateString": "2012-06-07 16:39:41"
}
]

}
```

--------------------------------

### Configure stateful scenarios in Java

Source: https://wiremock.org/docs/stateful-behaviour

Demonstrates defining a multi-step scenario using the Java DSL to simulate a to-do list application.

```java
@Test
public void toDoListScenario() {
    stubFor(get(urlEqualTo("/todo/items")).inScenario("To do list")
            .whenScenarioStateIs(STARTED)
            .willReturn(aResponse()
                    .withBody("<items>" +
                            "   <item>Buy milk</item>" +
                            "</items>")));


    stubFor(post(urlEqualTo("/todo/items")).inScenario("To do list")
            .whenScenarioStateIs(STARTED)
            .withRequestBody(containing("Cancel newspaper subscription"))
            .willReturn(aResponse().withStatus(201))
            .willSetStateTo("Cancel newspaper item added"));


    stubFor(get(urlEqualTo("/todo/items")).inScenario("To do list")
            .whenScenarioStateIs("Cancel newspaper item added")
            .willReturn(aResponse()
                    .withBody("<items>" +
                            "   <item>Buy milk</item>" +
                            "   <item>Cancel newspaper subscription</item>" +
                            "</items>")));


    WireMockResponse response = testClient.get("/todo/items");
    assertThat(response.content(), containsString("Buy milk"));
    assertThat(response.content(), not(containsString("Cancel newspaper subscription")));


    response = testClient.postWithBody("/todo/items", "Cancel newspaper subscription", "text/plain", "UTF-8");
    assertThat(response.statusCode(), is(201));


    response = testClient.get("/todo/items");
    assertThat(response.content(), containsString("Buy milk"));
    assertThat(response.content(), containsString("Cancel newspaper subscription"));
}
```

--------------------------------

### Retrieve logged requests JSON response

Source: https://wiremock.org/docs/standalone/admin-api-reference

Example JSON structure returned by the GET /__admin/requests endpoint.

```json
{
  "requests": [
    {
      "id": "45760a03-eebb-4387-ad0d-bb89b5d3d662",
      "request": {
        "url": "/received-request/9",
        "absoluteUrl": "http://localhost:56715/received-request/9",
        "method": "GET",
        "clientIp": "127.0.0.1",
        "headers": {
          "Connection": "keep-alive",
          "Host": "localhost:56715",
          "User-Agent": "Apache-HttpClient/4.5.1 (Java/1.7.0_51)"
        },
        "cookies": { },
        "browserProxyRequest": false,
        "loggedDate": 1471442494809,
        "bodyAsBase64": "",
        "body": "",
        "loggedDateString": "2016-08-17T14:01:34Z"
      },
      "responseDefinition": {
        "status": 404,
        "transformers": [ ],
        "fromConfiguredStub": false,
        "transformerParameters": { }
      }
    },
    {
      "id": "6ae78311-0178-46c9-987a-fbfc528d54d8",
      "request": {
        "url": "/received-request/8",
        "absoluteUrl": "http://localhost:56715/received-request/8",
        "method": "GET",
        "clientIp": "127.0.0.1",
        "headers": {
          "Connection": "keep-alive",
          "Host": "localhost:56715",
          "User-Agent": "Apache-HttpClient/4.5.1 (Java/1.7.0_51)"
        },
        "cookies": { },
        "browserProxyRequest": false,
        "loggedDate": 1471442494802,
        "bodyAsBase64": "",
        "body": "",
        "loggedDateString": "2016-08-17T14:01:34Z"
      },
      "responseDefinition": {
        "status": 404,
        "transformers": [ ],
        "fromConfiguredStub": false,
        "transformerParameters": { }
      }
    },
    {
      "id": "aba8e4ad-1b5b-4518-8f05-b2170a24de35",
      "request": {
        "url": "/received-request/7",
        "absoluteUrl": "http://localhost:56715/received-request/7",
        "method": "GET",
        "clientIp": "127.0.0.1",
        "headers": {
          "Connection": "keep-alive",
          "Host": "localhost:56715",
          "User-Agent": "Apache-HttpClient/4.5.1 (Java/1.7.0_51)"
        },
        "cookies": { },
        "browserProxyRequest": false,
        "loggedDate": 1471442494795,
        "bodyAsBase64": "",
        "body": "",
        "loggedDateString": "2016-08-17T14:01:34Z"
      },
      "responseDefinition": {
        "status": 404,
        "transformers": [ ],
        "fromConfiguredStub": false,
        "transformerParameters": { }
      }
    }
  ],
  "meta": {
    "total": 9
  },
  "requestJournalDisabled": false
}
```

--------------------------------

### Run with extensions

Source: https://wiremock.org/docs/standalone/docker

Mounts a local extensions directory and enables specific extensions via CLI parameters.

```bash
docker run -it --rm \
  -p 8080:8080 \
  --name wiremock \
  -v $PWD/extensions:/var/wiremock/extensions \
  wiremock/wiremock \
    --extensions org.wiremock.webhooks.Webhooks
```

--------------------------------

### WireMock 3.x JSON stub mappings output

Source: https://wiremock.org/docs/solutions/ai

Example of JSON stub mappings generated by an AI model, including GET and POST request patterns with inferred response bodies.

```json
{
  "mappings": [
    {
      "request": {
        "method": "GET",
        "urlPathPattern": "/api/users/\\d+"
      },
      "response": {
        "status": 200,
        "headers": { "Content-Type": "application/json" },
        "jsonBody": {
          "id": 1,
          "name": "Test User",
          "email": "user@example.com",
          "createdAt": "2024-01-01T00:00:00Z"
        }
      }
    },
    {
      "request": {
        "method": "POST",
        "urlPath": "/api/orders"
      },
      "response": {
        "status": 201,
        "headers": { "Content-Type": "application/json" },
        "jsonBody": {
          "orderId": "ord_abc123",
          "status": "created"
        }
      }
    },
    {
      "request": {
        "method": "GET",
        "urlPath": "/api/products",
        "queryParameters": {
          "category": { "anything": true }
        }
      },
      "response": {
        "status": 200,
        "headers": { "Content-Type": "application/json" },
        "jsonBody": {
          "items": [],
          "total": 0
        }
      }
    }
  ]
}
```

--------------------------------

### Initialize WireMockServer and WireMockRule

Source: https://wiremock.org/docs/configuration

Use the options() builder to pass configuration parameters to the WireMockServer or WireMockRule constructor.

```java
import static com.github.tomakehurst.wiremock.core.WireMockConfiguration.options;


WireMockServer wm = new WireMockServer(options().port(2345));


@Rule
WireMockRule wm = new WireMockRule(options().port(2345));
```

--------------------------------

### Initialize WireMock server with gRPC extension

Source: https://wiremock.org/docs/grpc

Configure the WireMock server to use the GrpcExtensionFactory and point to the directory containing your descriptor files.

```java
// Same config object also for the JUnit 4 rule or JUnit 5 extension
WireMockServer wm = new WireMockServer(wireMockConfig()
        .dynamicPort()
        .withRootDirectory("src/test/resources/wiremock")
        .extensions(new GrpcExtensionFactory())
));
```

--------------------------------

### trim

Source: https://wiremock.org/docs/response-templating

Removes whitespace from the start and end of a string.

```APIDOC
## trim

### Description
Use the `trim` helper to remove whitespace from the start and end of the input.

### Usage
- `{{trim request.headers.X-Padded-Header}}`

### Block Usage
```handlebars
{{#trim}}
    Some stuff with whitespace
{{/trim}}
```
```

--------------------------------

### GET /__admin/recordings/status

Source: https://wiremock.org/docs/standalone/admin-api-reference

Retrieves the current status of the recording session.

```APIDOC
## GET /__admin/recordings/status

### Description
Successfully got the record status.

### Method
GET

### Endpoint
/__admin/recordings/status

### Response
#### Success Response (200)
- **status** (string) - The current status of the recording (e.g., "Stopped").

#### Response Example
{
  "status": "Stopped"
}
```

--------------------------------

### Start Recording with Java DSL

Source: https://wiremock.org/docs/record-playback

Configures recording parameters using the Java DSL, including target URL, request filters, header capture, and body extraction thresholds.

```java
startRecording(
      recordSpec()
          .forTarget("http://examples.wiremockapi.cloud/")
          .onlyRequestsMatching(getRequestedFor(urlPathMatching("/api/.*")))
          .captureHeader("Accept")
          .captureHeader("Content-Type", true)
          .extractBinaryBodiesOver(10240)
          .extractTextBodiesOver(2048)
          .makeStubsPersistent(false)
          .ignoreRepeatRequests()
          .transformers("modify-response-header")
          .transformerParameters(Parameters.one("headerValue", "123"))
          .matchRequestBodyWithEqualToJson(false, true)
  );
```

--------------------------------

### GET /__admin/mappings/unmatched

Source: https://wiremock.org/docs/stubbing

Retrieves stub mappings that have not matched any requests.

```APIDOC
## GET /__admin/mappings/unmatched

### Description
Retrieves stub mappings that haven't matched any requests in the journal.

### Method
GET

### Endpoint
/__admin/mappings/unmatched
```

--------------------------------

### GET /__admin/mappings

Source: https://wiremock.org/docs/stubbing

Retrieves all currently registered stub mappings.

```APIDOC
## GET /__admin/mappings

### Description
Fetches all currently registered stub mappings. Supports optional pagination parameters.

### Method
GET

### Endpoint
/__admin/mappings

### Parameters
#### Query Parameters
- **limit** (integer) - Optional - Limits the number of results returned
- **offset** (integer) - Optional - The offset for the result set
```

--------------------------------

### Configure Proxying for Snapshotting

Source: https://wiremock.org/docs/record-playback

Sets up a proxy mapping to capture traffic for later snapshotting.

```java
stubFor(proxyAllTo("http://examples.wiremockapi.cloud/").atPriority(1));
```

```json
POST /__admin/mappings
{
    "priority": 1,
    "request": {
        "method": "ANY"
    },
    "response": {
        "proxyBaseUrl" : "http://examples.wiremockapi.cloud/"
    }
}
```

--------------------------------

### GET /__admin/messages

Source: https://wiremock.org/docs/messaging/verification

Retrieves a list of all recorded message events.

```APIDOC
## GET /__admin/messages

### Description
Retrieves all recorded message events.

### Method
GET

### Endpoint
/__admin/messages
```

--------------------------------

### GET /__admin/files

Source: https://wiremock.org/docs/standalone/admin-api-reference

Retrieves a list of all file names managed by WireMock.

```APIDOC
## GET /__admin/files

### Description
Returns a list of all file names.

### Method
GET

### Endpoint
/__admin/files

### Response
#### Success Response (200)
- **files** (array) - List of file names.

#### Response Example
["file1.json", "file2.json", "file3.txt"]
```

--------------------------------

### GET /__admin/message-mappings

Source: https://wiremock.org/docs/messaging/stubbing

Retrieves a list of all configured message stub mappings.

```APIDOC
## GET /__admin/message-mappings

### Description
Retrieves a list of all message stub mappings currently configured in the server.

### Method
GET

### Endpoint
http://localhost:8080/__admin/message-mappings
```

--------------------------------

### GET /__admin/channels

Source: https://wiremock.org/docs/messaging/sending-messages

Retrieves a list of all currently active message channels.

```APIDOC
## GET /__admin/channels

### Description
List all active message channels.

### Method
GET

### Endpoint
/__admin/channels
```

--------------------------------

### Using the systemValue helper

Source: https://wiremock.org/docs/response-templating

Prints environment variables or system properties.

```handlebars
{{systemValue key='PATH'}} <!-- type defaults to ENVIRONMENT -->
{{systemValue type='ENVIRONMENT' key='PATH'}}
{{systemValue type='PROPERTY' key='os.path'}}
```

--------------------------------

### Simulate a Chat Room with WebSockets

Source: https://wiremock.org/docs/websockets

Demonstrates setting up a message stub for broadcasting, connecting multiple clients, and verifying message delivery in a Java test environment.

```java
@Test
void chatRoomSimulation() {
    // Set up message stub for broadcasting
    messageStubFor(
        message()
            .withName("Chat broadcast")
            .onWebsocketChannelFromRequestMatching("/chat")
            .withBody(matchingJsonPath("$.type", equalTo("message")))
            .willTriggerActions(
                sendMessage("{{message.body}}")
                    .onChannelsMatching(
                        newRequestPattern().withUrl("/chat"))));


    // Connect two clients
    WebSocketClient alice = new WebSocketClient();
    WebSocketClient bob = new WebSocketClient();


    alice.connect("ws://localhost:" + wm.port() + "/chat");
    bob.connect("ws://localhost:" + wm.port() + "/chat");


    // Wait for connections
    await().until(() -> alice.isConnected() && bob.isConnected());


    // Alice sends a message
    alice.sendMessage("{\"type\": \"message\", \"from\": \"Alice\", \"text\": \"Hi Bob!\"}");


    // Both Alice and Bob receive it (including sender)
    await().until(() ->
        alice.getMessages().stream().anyMatch(m -> m.contains("Hi Bob!")) &&
        bob.getMessages().stream().anyMatch(m -> m.contains("Hi Bob!")));


    // Verify message was recorded
    verifyMessageEvent(
        messagePattern()
            .withBody(matchingJsonPath("$.from", equalTo("Alice")))
            .build());
}
```

--------------------------------

### GET /__admin/channels

Source: https://wiremock.org/docs/messaging/websockets

Retrieves a list of all currently active WebSocket channels.

```APIDOC
## GET /__admin/channels

### Description
Returns a list of all active WebSocket channels currently managed by the server.

### Method
GET

### Endpoint
/__admin/channels

### Response
#### Success Response (200)
- **channels** (array) - List of active channel objects

#### Response Example
{
  "channels": [
    {
      "id": "abc123",
      "type": "websocket",
      "initiatingRequest": {
        "url": "/my-websocket",
        "method": "GET"
      }
    }
  ]
}
```

--------------------------------

### Initialize gRPC service mock

Source: https://wiremock.org/docs/grpc

Create a service instance for the specific gRPC service defined in your proto files.

```java
WireMockGrpcService mockGreetingService =
    new WireMockGrpcService(
        new WireMock(wm.getPort()),
        "com.example.grpc.GreetingService"
    );
```

--------------------------------

### GET /__admin/health

Source: https://wiremock.org/docs/standalone/admin-api-reference

Returns the health status and uptime information of the WireMock server.

```APIDOC
## GET /__admin/health

### Description
Returns the health of the WireMock server.

### Method
GET

### Endpoint
/__admin/health

### Response
#### Success Response (200)
- **status** (string) - Health status
- **message** (string) - Status message
- **version** (string) - Server version
- **uptimeInSeconds** (integer) - Server uptime
- **timestamp** (string) - Current timestamp

#### Response Example
{
  "status": "healthy",
  "message": "Wiremock is ok",
  "version": "3.8.0",
  "uptimeInSeconds": 14355,
  "timestamp": "2024-07-03T13:16:06.172362Z"
}
```

--------------------------------

### Configure static client with imports

Source: https://wiremock.org/docs/java-usage

Use static imports to simplify DSL calls after configuring the client for a specific host.

```java
import static com.github.tomakehurst.wiremock.client.WireMock.*;


configureFor("wiremock.host", 8089);
stubFor(get(....));
```

--------------------------------

### Registering WireMock Extensions

Source: https://wiremock.org/docs/extending-wiremock

Demonstrates programmatic registration of extensions using class names, class references, or direct instances.

```java
new WireMockServer(wireMockConfig()
  .extensions("com.mycorp.BodyContentTransformer", "com.mycorp.HeaderMangler"));
```

```java
new WireMockServer(wireMockConfig()
  .extensions(BodyContentTransformer.class, HeaderMangler.class));
```

```java
new WireMockServer(wireMockConfig()
  .extensions(new BodyContentTransformer(), new HeaderMangler()));
```

--------------------------------

### GET /__admin/files/{fileId}

Source: https://wiremock.org/docs/standalone/admin-api-reference

Retrieves the contents of a specific file by its ID (name).

```APIDOC
## GET /__admin/files/{fileId}

### Description
Retrieves the content of a specific file.

### Method
GET

### Endpoint
/__admin/files/{fileId}

### Parameters
#### Path Parameters
- **fileId** (string) - Required - The name of the file.

### Response
#### Success Response (200)
- The contents of the file.
#### Error Response (404)
- File not found
```

--------------------------------

### Run a mock server with Stubr

Source: https://wiremock.org/docs/solutions/rust

Uses existing WireMock JSON stubs to initialize a mock server and perform assertions using reqwest and asserhttp.

```rust
use asserhttp::*;


#[tokio::test]
async fn getting_started() {
    // run a mock server with the stub 👇
    let stubr = stubr::Stubr::start("tests/stubs/hello.json").await;
    // or use 'start_blocking' for a non-async version


    // the mock server started on a random port e.g. '127.0.0.1:43125'
    // so we use the stub instance 'path' (or 'uri') method to get the address back
    let uri = stubr.path("/hello");
    reqwest::get(uri).await
        // (optional) use asserhttp for assertions
        .expect_status_ok()
        .expect_content_type_text()
        .expect_body_text_eq("Hello stubr");
}
```

--------------------------------

### GET /__admin/requests/{requestId}

Source: https://wiremock.org/docs/standalone/admin-api-reference

Retrieves a specific logged request by its unique identifier.

```APIDOC
## GET /__admin/requests/{requestId}

### Description
Retrieves a specific logged request by its unique identifier.

### Method
GET

### Endpoint
/__admin/requests/{requestId}

### Parameters
#### Path Parameters
- **requestId** (string) - Required - The UUID of the logged request

### Response
#### Success Response (200)
- OK

#### Error Response (404)
- Request not found

#### Response Example
{
  "id": "12fb14bb-600e-4bfa-bd8d-be7f12562c99",
  "request": {
    "url": "/received-request/2",
    "absoluteUrl": "http://localhost:56738/received-request/2",
    "method": "GET",
    "clientIp": "127.0.0.1",
    "headers": {
      "Connection": "keep-alive",
      "Host": "localhost:56738",
      "User-Agent": "Apache-HttpClient/4.5.1 (Java/1.7.0_51)"
    },
    "cookies": {},
    "browserProxyRequest": false,
    "loggedDate": 1471442557047,
    "bodyAsBase64": "",
    "body": "",
    "loggedDateString": "2016-08-17T14:02:37Z"
  },
  "responseDefinition": {
    "status": 404,
    "transformers": [],
    "fromConfiguredStub": false,
    "transformerParameters": {}
  }
}
```

--------------------------------

### GET /__admin/mappings/{id}

Source: https://wiremock.org/docs/stubbing

Retrieves a single stub mapping by its unique identifier.

```APIDOC
## GET /__admin/mappings/{id}

### Description
Retrieves a single stub mapping by its UUID.

### Method
GET

### Endpoint
/__admin/mappings/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - The UUID of the stub mapping
```

--------------------------------

### Build a custom Docker image

Source: https://wiremock.org/docs/standalone/docker

Creates a custom image by copying configuration files and overriding the entrypoint script.

```dockerfile
# Sample Dockerfile
FROM wiremock/wiremock:latest
COPY wiremock /home/wiremock
ENTRYPOINT ["/docker-entrypoint.sh", "--global-response-templating", "--disable-gzip", "--verbose"]
```

--------------------------------

### GET /__admin/requests/unmatched

Source: https://wiremock.org/docs/verifying

Retrieves a list of all requests that were received but not matched by a configured stub.

```APIDOC
## GET /__admin/requests/unmatched

### Description
Retrieves a list of all requests that were received but not matched by a configured stub.

### Method
GET

### Endpoint
/__admin/requests/unmatched

### Response
#### Success Response (200)
- **requests** (array) - List of unmatched requests
- **requestJournalDisabled** (boolean) - Status of the request journal

#### Response Example
{
  "requests" : [ {
    "url" : "/nomatch",
    "absoluteUrl" : "http://localhost:8080/nomatch",
    "method" : "GET",
    "clientIp" : "0:0:0:0:0:0:0:1",
    "headers" : {
      "User-Agent" : "curl/7.30.0",
      "Accept" : "*/*",
      "Host" : "localhost:8080"
    },
    "cookies" : { },
    "browserProxyRequest" : false,
    "loggedDate" : 1467402464520,
    "bodyAsBase64" : "",
    "body" : "",
    "loggedDateString" : "2016-07-01T19:47:44Z"
  } ],
  "requestJournalDisabled" : false
}
```

--------------------------------

### GET /__admin/messages/{id}

Source: https://wiremock.org/docs/messaging/verification

Retrieves a single message event by its unique ID.

```APIDOC
## GET /__admin/messages/{id}

### Description
Retrieves details for a specific message event using its ID.

### Method
GET

### Endpoint
/__admin/messages/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - The unique identifier of the message event.
```

--------------------------------

### Start WireMock with Admin API Basic Auth

Source: https://wiremock.org/docs/standalone/java-jar

Use the --admin-api-basic-auth flag to enforce authentication on the Admin API using a username:password format.

```bash
java -jar wiremock-standalone.jar --admin-api-basic-auth my-username:my-super-secret-password
```

--------------------------------

### Metadata search request payload

Source: https://wiremock.org/docs/standalone/admin-api-reference

Example JSON payload for the find-by-metadata endpoint.

```json
{
  * "matchesJsonPath": {
    * "expression": "$.outer",
    * "equalToJson": "{ \"inner\": 42 }"
}

}
```

--------------------------------

### Get request by ID

Source: https://wiremock.org/docs/standalone/admin-api-reference

Retrieves details of a specific logged request using its UUID.

```http
GET /__admin/requests/{requestId}
```
Tokens:
Raw