WireMock.NET

https://wiremock.org/dotnet/
Admin
WireMock.NET is a powerful .NET library for API mock testing, providing API simulation capabilities...
Tokens:43,322
Snippets:226
Trust Score:9.5
Update:11 months ago
Show doc for...
Tokens:
Raw
### Start a WireMock Server

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

Demonstrates how to start a WireMock server. The server can be configured to run on a specific port or will automatically select an available port.

```APIDOC
## Start a WireMock Server

### Description
Starts a WireMock server instance. If no port is specified, an available port will be automatically chosen.

### Method
Static method call

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
var server = WireMockServer.Start();
// To specify a port:
// var server = WireMockServer.Start(8080);
```

### Response
#### Success Response (200)
Indicates the server has started successfully. The `Port` property of the returned `WireMockServer` object can be used to determine the listening port.

#### Response Example
```csharp
// The server object itself is the result.
var server = WireMockServer.Start();
Console.WriteLine($"Server listening on port: {server.Port}");
```
```

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

### Start WireMock Server with HTTPS (C#)

Source: https://wiremock.org/dotnet/using-https-ssl

Demonstrates how to start a WireMock server instance configured to listen for HTTPS requests. This can be done by setting an 'ssl' flag to true or by explicitly defining HTTPS URLs in the server settings.

```csharp
var server1 = WireMockServer.Start(port: 8443, ssl: true);
```

```csharp
var server2 = WireMockServer.Start(new WireMockServerSettings
{
    Urls = new[] { "http://localhost:9091", "https://localhost:9443" }
});
```

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

### Basic HTTP GET Stubbing in C#

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

Configures a stub to return a 200 OK response with 'Hello world!' as the body and 'text/plain' content type for GET requests to '/some/thing'. Supports various HTTP methods like GET, POST, PUT, DELETE, HEAD, or any method using .UsingAny().

```csharp
var server = WireMockServer.Start();


server
  .Given(
    Request.Create().WithPath("/some/thing").UsingGet()
  )
  .RespondWith(
    Response.Create()
      .WithStatusCode(200)
      .WithHeader("Content-Type", "text/plain")
      .WithBody("Hello world!")
  );
```

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

### Start WireMock Server

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

Initiates a WireMock server instance. The server will bind to localhost on an available random port if no specific port is provided. The server's listening port can be accessed via the '_Port_' property.

```csharp
var server = WireMockServer.Start();
```

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

### Basic Stubbing with C#

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

Configures a response for a specific GET request matching a path and query parameters. Includes setting status code, headers, and body.

```APIDOC
## Basic Stubbing with C#

### Description
Configures a predefined HTTP response for a given request. This example sets up a response for a GET request to `/some/thing`.

### Method
`WireMockServer.Given().RespondWith()`

### Endpoint
`/some/thing` (relative path)

### Parameters
#### Path Parameters
None

#### Query Parameters
None (can be specified using `Request.Create().WithPathAndQuery()`)

#### Request Body
None for this specific example, but can be used with `UsingPostAsJson()` etc.

### Request Example
```csharp
var server = WireMockServer.Start();

server
  .Given(
    Request.Create().WithPath("/some/thing").UsingGet()
  )
  .RespondWith(
    Response.Create()
      .WithStatusCode(200)
      .WithHeader("Content-Type", "text/plain")
      .WithBody("Hello world!")
  );
```

### Response
#### Success Response (200)
- **Content-Type** (string) - `text/plain`
- **Body** (string) - `Hello world!`

#### Response Example
```json
{
  "msg": "Hello world!"
}
```
```

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

### Build and Start WireMock Docker Container (C#)

Source: https://wiremock.org/dotnet/using-wiremock-net-testcontainers

This code snippet demonstrates how to build and start a WireMock Docker container using the WireMockContainerBuilder. It configures the container for automatic removal and cleanup after use. The container is started asynchronously.

```csharp
var container = new WireMockContainerBuilder()
    .WithAutoRemove(true)
    .WithCleanUp(true)
    .Build();


await container.StartAsync().ConfigureAwait(false);
```

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

### Start WireMock Server with Admin Interface - C#

Source: https://wiremock.org/dotnet/admin-api-reference

Initializes a WireMock server with admin interface enabled. This is the minimal setup required to enable dynamic API mapping configuration via HTTP endpoints. The server will listen on a dynamically assigned port.

```csharp
var server = WireMockServer.StartWithAdminInterface();
```

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

### WireMock Unit Test Setup with NUnit in C#

Source: https://wiremock.org/dotnet/using-wiremock-in-unittests

This snippet demonstrates setting up a WireMock.Net server in NUnit unit tests, defining a mock response for a GET request, and asserting the result using NFluent. It ensures tests are not flaky by using dynamic ports and cleaning up the server after each test. Dependencies include WireMock.Net, NUnit, NFluent, and System.Net.Http for HttpClient.

```C#
[SetUp]
public void StartMockServer()
{
    _server = WireMockServer.Start();
}

[Test]
public async Task Should_respond_to_request()
{
  // Arrange (start WireMock.Net server)
  _server
    .Given(Request.Create().WithPath("/foo").UsingGet())
    .RespondWith(
      Response.Create()
        .WithStatusCode(200)
        .WithBody(@"{ ""msg"": ""Hello world!"" }")
    );

  // Act (use a HttpClient which connects to the URL where WireMock.Net is running)
  var response = await new HttpClient().GetAsync($"{_server.Urls[0]}/foo");

  // Assert
  Check.That(response).IsEqualTo(EXPECTED_RESULT);
}

[TearDown]
public void ShutdownServer()
{
    _server.Stop();
}
```

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

### Get All Mappings - JSON Example

Source: https://wiremock.org/dotnet/admin-api-reference

Provides an example of the JSON response received when querying the /__admin/mappings endpoint to retrieve all defined mappings. Each mapping includes details about the request (path, methods, headers, etc.) and the corresponding response (status code, body, headers, delay).

```json
[
  {
    "Guid": "be6e1db8-cb95-4a15-a836-dcd0092b34a0",
    "Request": {
      "Path": {
        "Matchers": [
          {
            "Name": "WildcardMatcher",
            "Pattern": "/data"
          }
        ]
      },
      "Methods": [
        "get"
      ],
      "Headers": [
        {
          "Name": "Content-Type",
          "Matchers": [
            {
              "Name": "WildcardMatcher",
              "Pattern": "application/*"
            }
          ]
        }
      ],
      "Cookies": [],
      "Params": [
        {
          "Name": "start",
          "Values": [ "1000", "1001" ]
        }
      ],
      "Body": {}
    },
    "Response": {
      "StatusCode": 200,
      "Body": "{ \"result\": \"Contains x with FUNC 200\"}",
      "UseTransformer": false,
      "Headers": {
        "Content-Type": "application/json"
      }
    }
  },
  {
    "Guid": "90356dba-b36c-469a-a17e-669cd84f1f05",
    "Request": {
      "Path": {
        "Matchers": [
          {
            "Name": "WildcardMatcher",
            "Pattern": "/*"
          }
        ]
      },
      "Methods": [
        "get"
      ],
      "Headers": [],
      "Cookies": [],
      "Params": [
        {
          "Name": "start",
          "Values": []
        }
      ],
      "Body": {}
    },
    "Response": {
      "StatusCode": 200,
      "Body": "{\"msg\": \"Hello world, {{request.path}}\"",
      "UseTransformer": true,
      "Headers": {
        "Transformed-Postman-Token": "token is {{request.headers.Postman-Token}}",
        "Content-Type": "application/json"
      },
      "Delay": 10
    }
  }
]
```

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

### JSON Mapping Example

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

Shows how to define the same stub mapping as the C# example, but using a JSON configuration.

```APIDOC
## JSON Mapping Example

### Description
Defines an HTTP stub using a JSON structure. This is equivalent to the C# basic stubbing example.

### Method
JSON configuration

### Endpoint
`/some/thing`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
JSON object defining request matching and response.

### Request Example
```json
{
    "Request": {
        "Path": {
            "Matchers": [
                {
                    "Name": "WildcardMatcher",
                    "Pattern": "/some/thing"
                }
            ]
        },
        "Methods": [
            "get"
        ]
    },
    "Response": {
        "StatusCode": 200,
        "Body": "Hello world!",
        "Headers": {
            "Content-Type": "text/plain"
        }
    }
}
```

### Response
#### Success Response (200)
- **Content-Type** (string) - `text/plain`
- **Body** (string) - `Hello world!`

#### Response Example
```json
{
  "msg": "Hello world!"
}
```
```

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

### JSON Mapping for HTTP Stubbing

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

Defines an HTTP stub using a JSON structure. This example maps a GET request to '/some/thing' to a response with status 200, 'Hello world!' body, and 'text/plain' content type, equivalent to the C# basic stubbing example.

```json
{
    "Request": {
        "Path": {
            "Matchers": [
                {
                    "Name": "WildcardMatcher",
                    "Pattern": "/some/thing"
                }
            ]
        },
        "Methods": [
            "get"
        ]
    },
    "Response": {
        "StatusCode": 200,
        "Body": "Hello world!",
        "Headers": {
            "Content-Type": "text/plain"
        }
    }
}
```

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

### Wiremock .NET GET Request Mapping Example

Source: https://wiremock.org/dotnet/wiremock-java-compatibility

Example of a WireMock .NET mapping for a GET request. This JSON structure defines the request URL, method, and the expected response, including status, body, and headers. It is compatible with mappings generated by WireMock Java.

```json
{
  "id" : "ef53ea56-f118-4b3a-8c69-a9484851d99a",
  "name" : "weatherforecast",
  "request" : {
    "url" : "/WeatherForecast",
    "method" : "GET"
  },
  "response" : {
    "status" : 200,
    "body" : "[{{\"date\":\"2021-09-09T20:44:48.0992639-03:00\",\"temperatureC\":51,\"temperatureF\":123,\"summary\":\"Hot\"}},{{\"date\":\"2021-09-10T20:44:48.0992692-03:00\",\"temperatureC\":34,\"temperatureF\":93,\"summary\":\"Mild\"}},{{\"date\":\"2021-09-11T20:44:48.0992696-03:00\",\"temperatureC\":43,\"temperatureF\":109,\"summary\":\"Sweltering\"}},{{\"date\":\"2021-09-12T20:44:48.0992698-03:00\",\"temperatureC\":46,\"temperatureF\":114,\"summary\":\"Cool\"}},{{\"date\":\"2021-09-13T20:44:48.0992701-03:00\",\"temperatureC\":3,\"temperatureF\":37,\"summary\":\"Freezing\"}}]",
    "headers" : {
      "Date" : "Wed, 08 Sep 2021 23:44:47 GMT",
      "Content-Type" : "application/json; charset=utf-8",
      "Server" : "Kestrel"
    }
  },
  "uuid" : "ef53ea56-f118-4b3a-8c69-a9484851d99a",
  "persistent" : true,
  "insertionIndex" : 1
}
```

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

### Get Request Info via C#

Source: https://wiremock.org/dotnet/request-matching-tips

This snippet demonstrates how to retrieve request information using C# code and the WireMock.Net library. It starts a WireMock server and accesses the server's log entries to inspect request details. This is helpful for debugging matching issues.

```C#
var server = WireMockServer.Start();
var logEntries = server.LogEntries;
```

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

### Configure stateful mock API using scenarios in C#

Source: https://wiremock.org/dotnet/scenarios-and-states

This example demonstrates how to set up a stateful mock API in WireMock.Net using scenarios. It defines a to-do list API that returns different responses based on the scenario state. The initial GET request returns 'Buy milk', after a POST request the state changes, and subsequent GET requests return an updated list.

```csharp
// Assign
_server = WireMockServer.Start();


_server
  .Given(Request.Create()
    .WithPath("/todo/items")
    .UsingGet())
  .InScenario("To do list")
  .WillSetStateTo("TodoList State Started")
  .RespondWith(Response.Create()
    .WithBody("Buy milk"));


_server
  .Given(Request.Create()
    .WithPath("/todo/items")
    .UsingPost())
  .InScenario("To do list")
  .WhenStateIs("TodoList State Started")
  .WillSetStateTo("Cancel newspaper item added")
  .RespondWith(Response.Create()
    .WithStatusCode(201));


_server
  .Given(Request.Create()
    .WithPath("/todo/items")
    .UsingGet())
  .InScenario("To do list")
  .WhenStateIs("Cancel newspaper item added")
  .RespondWith(Response.Create()
    .WithBody("Buy milk;Cancel newspaper subscription"));


// Act and Assert
string url = "http://localhost:" + _server.Ports[0];
string getResponse1 = await new HttpClient().GetStringAsync(url + "/todo/items");
Check.That(getResponse1).Equals("Buy milk");


var postResponse = await new HttpClient().PostAsync(url + "/todo/items", new StringContent("Cancel newspaper subscription"));
Check.That(postResponse.StatusCode).Equals(HttpStatusCode.Created);


string getResponse2 = await new HttpClient().GetStringAsync(url + "/todo/items");
Check.That(getResponse2).Equals("Buy milk;Cancel newspaper subscription");
```

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

### C# Example for a body with bytes

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

Demonstrates how to configure a response body using a byte array.

```APIDOC
## C# Example for a body with bytes

### Description
Configures a stub response where the body is provided as a byte array.

### Method
`WireMockServer.Given().RespondWith().WithBody(byte[])`

### Endpoint
`/some/thing`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None for this specific example.

### Request Example
```csharp
var server = WireMockServer.Start();
server
  .Given(
    Request.Create().WithPath("/some/thing").UsingGet()
  )
  .RespondWith(
    Response.Create()
      .WithBody(new byte[] { 48, 65, 6c, 6c, 6f }) // Represents "Hello" in ASCII
  );
```

### Response
#### Success Response (200)
- **Body** (byte[]) - The provided byte array.

#### Response Example
```
[48, 65, 6c, 6c, 6f]
```
```

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

### Start WireMock server with default settings in C#

Source: https://wiremock.org/dotnet/wiremock-as-a-standalone-process

Launches a WireMock server with default settings using the WireMock.Net.StandAlone library. The server runs until a key is pressed. Requires WireMock.Net.StandAlone NuGet package.

```C#
class Program
{
    static void Main(string[] args)
    {
        StandAloneApp.Start(args);

        Console.WriteLine("Press any key to stop the server");
        Console.ReadKey();
    }
}
```

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

### Configuring Global Proxy in WireMock.NET

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

This setup starts the WireMock server in proxy mode to forward all requests to a target URL like samples.openweathermap.org while recording and saving mappings for 2xx status codes. It requires WireMockServerSettings and ProxyAndRecordSettings; dependencies include WireMock.NET library. Inputs are server configuration options; outputs a running proxied server accessible at localhost:9095, with admin interface enabled. Limitations: proxies all requests unless overridden by stubs.

```csharp
var settings = new WireMockServerSettings
{
    Urls = new[] { "https://localhost:9095/" },
    StartAdminInterface = true,
    ProxyAndRecordSettings = new ProxyAndRecordSettings
    {
        Url = "https://samples.openweathermap.org",
        SaveMapping = true,
        SaveMappingToFile = true,
        SaveMappingForStatusCodePattern = "2xx"
    }
};


var server = WireMockServer.Start(settings);
```

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

### C# JsonPathMatcher Example for WireMock

Source: https://wiremock.org/dotnet/request-matching-jsonpathmatcher

Demonstrates how to configure a WireMock server in C# to match requests using a JsonPathMatcher. This requires the WireMock.Net NuGet package. It specifies a GET request to '/some/thing' where the request body must match the provided JSON Path expression.

```csharp
var server = WireMockServer.Start();
server
  .Given(
    Request.Create().WithPath("/some/thing").UsingGet()
      .WithBody(new JsonPathMatcher("$.things[?(@.name == 'RequiredThing')]")));
  )
  .RespondWith(Response.Create().WithBody("Hello"));
```

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

### Scriban Template Example

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

Example of using Scriban as the templating engine for response generation.

```APIDOC
## POST /template

### Description
Example of configuring a response to use Scriban for templating, either in C# or via JSON configuration.

### Method
POST

### Endpoint
/template

### Request Body
- **TransformerType** (string) - Required - Set to "Scriban" or "ScribanDotLiquid" to use Scriban templating.

### Response
#### Success Response (200)
- **body** (string) - The response body generated using Scriban templating.

#### Response Example
```
Hello, dynamically generated content!
```
```

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

### Start WireMock server with custom settings in C#

Source: https://wiremock.org/dotnet/wiremock-as-a-standalone-process

Launches a WireMock server with custom configuration using the WireMockServerSettings object. Demonstrates enabling partial mappings and admin interface. Requires WireMock.Net.StandAlone NuGet package.

```C#
class Program
{
    static void Main(string[] args)
    {
        var settings = new WireMockServerSettings
            {
                AllowPartialMapping=true,
                StartAdminInterface=true
            };
        StandAloneApp.Start(settings);

        Console.WriteLine("Press any key to stop the server");
        Console.ReadKey();
    }
}
```

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

### Create HTTP Client for WireMock (C#)

Source: https://wiremock.org/dotnet/using-wiremock-net-testcontainers

This snippet illustrates how to create a standard HTTP client to communicate with a running WireMock container. It shows how to make a GET request to a WireMock endpoint.

```csharp
var client = container.CreateClient();
var result = await client.GetStringAsync("/test123");
```

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

### C# Stubbing with Byte Array Response Body

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

Demonstrates how to configure a stub response using a byte array for the request body. The example sends a specific byte sequence (equivalent to 'Hello') for requests matching '/some/thing'.

```csharp
var server = WireMockServer.Start();
server
  .Given(
    Request.Create().WithPath("/some/thing").UsingGet()
  )
  .RespondWith(
    Response.Create()
      .WithBody(new byte[] { 48, 65, 6c, 6c, 6f })
  );
```

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

### Handlebars.Net Template Example

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

Example of using Handlebars.Net to dynamically generate a response based on a request path.

```APIDOC
## GET /some/thing

### Description
Dynamically generates a response that includes the request path using Handlebars.Net templating.

### Method
GET

### Endpoint
/some/thing

### Response
#### Success Response (200)
- **body** (string) - The response body includes the request path.

#### Response Example
```
Hello world! Your path is /some/thing.
```
```

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

### Route-Level Delay Simulation in C#

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

Applies a specific delay to responses for a particular route. This example configures the '/slow' path to have a 10-second delay before returning a JSON response, demonstrating granular control over response timing.

```csharp
var server = WireMockServer.Start();
server
  .Given(Request.Create().WithPath("/slow"))
  .RespondWith(
    Responses.Create()
      .WithStatusCode(200)
      .WithBody(@"{ "msg": "Hello I'm a little bit slow!" }")
      .WithDelay(TimeSpan.FromSeconds(10)
    )
  );
```

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

### Verify Interactions

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

Shows how to access the log of received requests to verify interactions with the WireMock server.

```APIDOC
## Verify Interactions

### Description
Accesses the log of requests received by the WireMock server, allowing for verification of interactions during tests.

### Method
`server.LogEntries` property and `server.FindLogEntries()` method

### Endpoint
N/A (accesses server logs)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None for accessing logs.

### Request Example
```csharp
var server = WireMockServer.Start();

// Get all log entries
var allLogEntries = server.LogEntries;

// Find specific log entries based on request criteria
var customerReadRequests = server.FindLogEntries(
    Request.Create().WithPath("/api/customer*").UsingGet()
);
```

### Response
#### Success Response (200)
- **LogEntries** (IEnumerable<LogEntry>) - A collection of all requests received by the server.
- **FindLogEntries Result** (IEnumerable<LogEntry>) - A filtered collection of log entries matching the specified criteria.

#### Response Example
```json
// Example of a single LogEntry object structure
{
  "RequestMessage": {
    "Method": "GET",
    "Path": "/api/customer/123",
    "Query": "?details=true",
    "Headers": {
      "Content-Type": "application/json"
    },
    "Body": "{ \"some\": \"data\" }"
  },
  "ResponseMessage": {
    "StatusCode": 200,
    "Headers": {
      "Content-Type": "application/json"
    },
    "Body": "{ \"customerName\": \"John Doe\" }"
  },
  "Timing": {
    "RequestToJava": 10,
    "ResponseToJava": 50,
    "Total": 60
  }
}
```
```

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

### Generate and Export SSL Certificate (Linux - OpenSSL)

Source: https://wiremock.org/dotnet/using-https-ssl

Commands to generate an SSL certificate and its private key using OpenSSL on Linux, based on a provided configuration file. It then exports these into a PFX file, which can be used by WireMock.Net.

```bash
openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout localhost.key -out localhost.crt -config localhost.conf -subj /CN=localhost
openssl pkcs12 -export -out localhost.pfx -inkey localhost.key -in localhost.crt -passout pass:
```

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

### Wiremock .NET POST Request Mapping Example

Source: https://wiremock.org/dotnet/wiremock-java-compatibility

Example of a WireMock .NET mapping for a POST request. This JSON defines the request URL, method, and a request body pattern. It also specifies the expected response status and headers. This mapping is compatible with those generated by WireMock Java.

```json
{
  "id" : "365dd908-dc67-4f27-9e41-15d908206d81",
  "name" : "weatherforecast_register-city",
  "request" : {
    "url" : "/WeatherForecast/register-city",
    "method" : "POST",
    "bodyPatterns" : [ {
      "equalToJson" : "{ \"cityName\": \"São Paulo\", \"cityCode\": 5001 }",
      "ignoreArrayOrder" : true,
      "ignoreExtraElements" : true
    } ]
  },
  "response" : {
    "status" : 200,
    "headers" : {
      "Date" : "Wed, 08 Sep 2021 23:48:33 GMT",
      "Server" : "Kestrel"
    }
  },
  "uuid" : "365dd908-dc67-4f27-9e41-15d908206d81",
  "persistent" : true,
  "insertionIndex" : 4
}
```

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

### C# - JSON Partial Matcher Example

Source: https://wiremock.org/dotnet/request-matching-jsonpartialmatcher

Demonstrates setting up a WireMock server in C# to match requests with a partial JSON body. The example matches any POST request to '/jsonpartialmatcher1' with a body containing the specified JSON fragment.

```C#
var server = WireMockServer.Start();
server
  .Given(Request
    .Create()
      .WithPath("/jsonpartialmatcher1")
      .WithBody(new JsonPartialMatcher("{ \"test\": \"abc\" }"))
      .UsingPost())
  .WithGuid("debaf408-3b23-4c04-9d18-ef1c020e79f2")
  .RespondWith(Response.Create().WithBody(@"{ \"result\": \"jsonpartialbodytest1\" }"));
```

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

### Pre-load Mappings from JSON File - JSON

Source: https://wiremock.org/dotnet/admin-api-reference

Illustrates the use of pre-loaded mappings by specifying the filename format.  Mappings are expected to be stored in the __admin\mapping directory with the filename matching the GUID.

```json
{
    "Request": {
        "Path": {
            "Matchers": [
                {
                    "Name": "WildcardMatcher",
                    "Pattern": "/static/mapping"
                }
            ]
        },
        "Methods": [
            "get"
        ]
    },
    "Response": {
        "BodyAsJson": { "body": "static mapping" },
        "Headers": {
            "Content-Type": "application/json"
        }
    }
}
```

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

### JSON Mapping - JSON Partial Matcher Example

Source: https://wiremock.org/dotnet/request-matching-jsonpartialmatcher

Shows how to define a JSON mapping for partial matching in WireMock. The configuration includes path, method, and body matchers, with a response template.

```JSON
{
    "Guid": "debaf408-3b23-4c04-9d18-ef1c020e79f2",
    "Request": {
        "Path": {
            "Matchers": [
                {
                    "Name": "WildcardMatcher",
                    "Pattern": "/jsonpartialmatcher1"
                }
            ]
        },
        "Methods": [
            "post"
        ],
        "Body": {
            "Matcher": {
                "Name": "JsonPartialMatcher",
                "Pattern": "{ \"test\": \"abc\" }"
            }
        }
    },
    "Response": {
        "StatusCode": 200,
        "Body": "{ \"result\": \"jsonpartialbodytest1\" }",
        "UseTransformer": false
    }
}
```

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

### Match Request Headers - WireMock.Net

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

Provides examples for header matching, including presence and wildcard patterns. JSON configurations use Headers array with matchers or RejectOnMatch for absent headers. No code for C# in examples; JSON-only; input is header name and optional pattern; supports case-insensitive and rejection on match for missing headers.

```json
{
  "Request": {
    "Headers": [
      {
        "Name": "api-key",
        "Matchers": [
          {
            "Name": "WildcardMatcher",
            "Pattern": "abc*"
            "IgnoreCase": true
          }
        ]
      }
    ]
  }
}

```

```json
{
  "Request": {
    "Headers": [
    {
      "Name": "api-key",
      "IgnoreCase": true,
      "RejectOnMatch": true
    }
  ]
}
}

```

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

### Configure Docker Container for HTTPS Certificate (Dockerfile)

Source: https://wiremock.org/dotnet/using-https-ssl

Illustrates Dockerfile commands to copy SSL certificate files into a container and trust them. This ensures that the ASP.NET Core runtime within the container recognizes the self-signed certificate for HTTPS.

```dockerfile
COPY localhost.crt /usr/local/share/ca-certificates/
RUN dotnet dev-certs https --clean \
    && update-ca-certificates
COPY localhost.pfx /root/.dotnet/corefx/cryptography/x509stores/my/
```

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

### GET /__admin/requests

Source: https://wiremock.org/dotnet/request-matching-tips

Retrieves information about requests sent to WireMock.Net. This endpoint is useful for diagnosing '404 Not Found' errors by providing details about the incoming request and the best matching mapping found, along with matching results.

```APIDOC
## GET /__admin/requests

### Description
Retrieves information about requests that have been sent to the WireMock server. This endpoint is particularly useful when a request does not match any defined mapping, resulting in a 404 response. The response includes details about the request, the closest matching mapping found (if any), and a breakdown of the matching process.

### Method
GET

### Endpoint
`http://{{wm_hostname}}/__admin/requests`

### Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **Response** (object) - Details of the response returned by WireMock.
  - **StatusCode** (integer) - The HTTP status code of the response.
  - **Headers** (object) - Headers of the response.
  - **BodyAsJson** (object) - The response body if it was JSON.
  - **DetectedBodyType** (integer) - Indicates the detected type of the response body.
  - **DetectedBodyTypeFromContentType** (integer) - Indicates the detected type based on the Content-Type header.
- **PartialMappingGuid** (string) - The unique identifier of the closest matching mapping found.
- **PartialMappingTitle** (string) - The title of the closest matching mapping found.
- **PartialRequestMatchResult** (object) - An object detailing the results of the matching process for the request.
  - **TotalScore** (number) - The overall score of the match.
  - **TotalNumber** (integer) - The total number of matchers evaluated.
  - **IsPerfectMatch** (boolean) - Indicates if the match was perfect.
  - **AverageTotalScore** (number) - The average score across all matchers.
  - **MatchDetails** (array) - An array of objects, each detailing the result of a specific matcher.
    - **Name** (string) - The name of the matcher (e.g., PathMatcher, MethodMatcher).
    - **Score** (number) - The score achieved by this matcher.

#### Response Example
```json
{
  "Response": {
    "StatusCode": 404,
    "Headers": {
      "Content-Type": [
        "application/json"
      ]
    },
    "BodyAsJson": {
      "Status": "No matching mapping found"
    },
    "DetectedBodyType": 2,
    "DetectedBodyTypeFromContentType": 0
  },
  "PartialMappingGuid": "bb4c0d1d-ef2e-4cd2-966a-850b8f1a2829",
  "PartialMappingTitle": "Fetch_User_By_Id_66",
  "PartialRequestMatchResult": {
    "TotalScore": 2.0,
    "TotalNumber": 3,
    "IsPerfectMatch": false,
    "AverageTotalScore": 0.66666666666666663,
    "MatchDetails": [
      {
        "Name": "PathMatcher",
        "Score": 0.0
      },
      {
        "Name": "MethodMatcher",
        "Score": 1.0
      },
      {
        "Name": "BodyMatcher",
        "Score": 1.0
      }
    ]
  }
}
```
```

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

### GET /__admin/requests/{guid}

Source: https://wiremock.org/dotnet/admin-api-reference

Retrieves a single logged request identified by its GUID.

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

### Description
Retrieves a single logged request identified by its unique identifier.

### Method
GET

### Endpoint
`/__admin/requests/{guid}`

### Parameters
#### Path Parameters
- **guid** (string) - Required - The unique identifier of the logged request to retrieve.

### Response
#### Success Response (200)
- **(The full logged request object)**

#### Response Example
```json
{
  "id": "some-guid",
  "url": "/specific/request",
  "method": "POST",
  "body": "{\"data\": \"example\"}",
  "headers": {}
}
```
```

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

### GET /__admin/mappings/{guid}

Source: https://wiremock.org/dotnet/admin-api-reference

Retrieves a single stub mapping identified by its GUID.

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

### Description
Retrieves a single stub mapping by its unique identifier.

### Method
GET

### Endpoint
`/__admin/mappings/{guid}`

### Parameters
#### Path Parameters
- **guid** (string) - Required - The unique identifier of the stub mapping to retrieve.

### Response
#### Success Response (200)
- **(The full stub mapping object, including Request and Response definitions)**

#### Response Example
```json
{
  "Guid": "dae02a0d-8a33-46ed-aab0-afbecc8643e3",
  "Request": {
    "Path": "/testabc",
    "Methods": [
      "put"
    ]
  },
  "Response": {
    "Body": "Response Body"
  }
}
```
```

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

### Simulate Malformed Response Chunk in C#

Source: https://wiremock.org/dotnet/faults

Configures WireMock.Net to respond with a malformed response chunk for a specific GET request. This is useful for testing how clients handle corrupted data streams. The fault occurs with a 50% probability.

```csharp
var server = WireMockServer.Start();


server
    .Given(Request.Create().WithPath("/fault").UsingGet())
    .RespondWith(Response.Create()
        .WithStatusCode(201)
        .WithHeader("Content-Type", "application/json")
        .WithBody(@"{ \"result\": 100 }")
        .WithFault(FaultType.MALFORMED_RESPONSE_CHUNK, 0.5));
```

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

### Configure Standalone Server with Azure AD - C#

Source: https://wiremock.org/dotnet/admin-api-reference

Configures and starts a WireMock standalone server with Azure AD authentication enabled. Includes SSL support, console logging, and partial mapping allowance. Demonstrates required settings for AdminAzureADTenant and AdminAzureADAudience.

```csharp
using WireMock.Logging;
using WireMock.Net.StandAlone;
using WireMock.Settings;


var settings = new WireMockServerSettings
{
    AllowPartialMapping=true,
    Logger = new WireMockConsoleLogger(),
    UseSSL = true,
    AdminAzureADTenant = "AadTennatId",
    AdminAzureADAudience = "AadAudience",
    StartAdminInterface=true
};


StandAloneApp.Start(settings);


Console.WriteLine("Press any key to stop the server");
Console.ReadKey();
```

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

### Define Main Proto Definition File

Source: https://wiremock.org/dotnet/request-matching-protobuf

This proto file defines the Greeter service and HelloReply message, and imports another proto file for the HelloRequest message. It serves as the primary definition for the gRPC service.

```protobuf
syntax = "proto3";


import "request.proto";


package greet;


service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}


message HelloReply {
  string message = 1;
}

```

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

### Multiple Proto Definition Files Configuration

Source: https://wiremock.org/dotnet/request-matching-protobuf

Guidance on how to configure WireMock.Net when dealing with multiple ProtoBuf definition files, emphasizing the order and commenting requirements for imported files.

```APIDOC
## Multiple Proto Definition Files Setup

### Description
When using multiple ProtoBuf definition files (e.g., a main file and imported files), WireMock.Net requires specific handling to correctly resolve dependencies between them.

### Rules
1.  **Main Proto File**: The first file provided in the array to `AddProtoDefinition` must be the primary proto file.
2.  **Referenced Files**: Each referenced (imported) proto file must be provided as a separate argument to `AddProtoDefinition` to ensure WireMock.Net can resolve them.

### C# Configuration Snippet
```csharp
var greetProto = File.ReadAllText(@"c:\grpc\greet.proto");
var requestProto = File.ReadAllText(@"c:\grpc\request.proto");
var protoDefinitionId = "GrpcMultiProto";

var server = WireMockServer.Start(useHttp2: true);

server
  // Register multiple proto definitions, with the main file first
  .AddProtoDefinition(protoDefinitionId, greetProto, requestProto)
  // ... rest of the mapping configuration ...
  .Given(Request.Create()
    .UsingPost()
    .WithPath("/grpc/some.service/SomeMethod")
    // Use a matcher that relies on the defined proto definitions
    .WithBodyAsProtoBuf("greet.HelloRequest", new JsonMatcher(new { name = "test" }))
  )
  .WithProtoDefinition(protoDefinitionId)
  .RespondWith(Response.Create()
    .WithHeader("Content-Type", "application/grpc")
    .WithBodyAsProtoBuf("greet.HelloReply", new { message = "Success" })
  );
```

### Proto Definition Examples
#### Main proto (`greet.proto`)
```protobuf
syntax = "proto3";

import "request.proto"; // Imported proto file

package greet;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloReply {
  string message = 1;
}
```

#### Other proto file (`request.proto`)
```protobuf
syntax = "proto3";

package greet;

message HelloRequest {
  string name = 1;
}
```
```

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

### JsonPathMatcher Matching and Non-Matching Examples

Source: https://wiremock.org/dotnet/request-matching-jsonpathmatcher

Provides examples of JSON request bodies that will match and will not match a JsonPathMatcher configured with the expression '$.things[?(@.name == 'RequiredThing')]'. Matching examples include single objects and arrays containing the required element. Non-matching examples show incorrect structure or values.

```json
// matching
{ "things": { "name": "RequiredThing" } }
{ "things": [ { "name": "RequiredThing" }, { "name": "Wiremock" } ] }


// not matching
{ "price": 15 }
{ "things": { "name": "Wiremock" } }
```

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

### DELETE /__admin/mappings/{guid}

Source: https://wiremock.org/dotnet/admin-api-reference

Deletes a single stub mapping identified by its GUID.

```APIDOC
## DELETE /__admin/mappings/{guid}

### Description
Deletes a single stub mapping identified by its unique identifier.

### Method
DELETE

### Endpoint
`/__admin/mappings/{guid}`

### Parameters
#### Path Parameters
- **guid** (string) - Required - The unique identifier of the stub mapping to delete.

### Response
#### Success Response (200)
- **(No specific fields defined, typically returns a success status)**

#### Response Example
```json
// Typically an empty success response or a confirmation message
```
```

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

### Accessing Log Entries via C# Code

Source: https://wiremock.org/dotnet/request-matching-tips

Demonstrates how to programmatically access log entries from a running WireMock.Net server instance using C# code. This allows for detailed inspection of requests and responses within an application context.

```APIDOC
## Accessing Log Entries via C# Code

### Description
This section provides a C# code example illustrating how to obtain log entries from a WireMock server instance. This is useful for debugging and gaining insights into the server's activity, especially when diagnosing request matching issues.

### Method
N/A (C# Code Snippet)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
#### Success Response (200)
N/A

#### Response Example
```csharp
using WireMock.Server;

// Start the WireMock server
var server = WireMockServer.Start();

// Access the log entries
var logEntries = server.LogEntries;

// You can now iterate through logEntries to inspect request and response details
foreach (var entry in logEntries)
{
    // Process each log entry
    Console.WriteLine($"Request Received: {entry.RequestMessage.AbsoluteUri}");
}

// To stop the server when done:
// server.Stop();
```
```

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

### PUT /__admin/mappings/{guid}

Source: https://wiremock.org/dotnet/admin-api-reference

Updates an existing stub mapping identified by its GUID.

```APIDOC
## PUT /__admin/mappings/{guid}

### Description
Updates an existing stub mapping identified by its unique identifier.

### Method
PUT

### Endpoint
`/__admin/mappings/{guid}`

### Parameters
#### Path Parameters
- **guid** (string) - Required - The unique identifier of the stub mapping to update.

#### Request Body
- **Request** (object) - Required - Defines the incoming request to match.
  - **Path** (object) - Optional - Defines path matchers.
  - **Methods** (array of strings) - Required - The HTTP methods to match.
  - **Headers** (array of objects) - Optional - Headers to match.
  - **Cookies** (array of objects) - Optional - Cookies to match.
  - **Params** (array of objects) - Optional - Query parameters to match.
  - **Body** (object) - Optional - Request body to match.
- **Response** (object) - Required - Defines the response to return.
  - **StatusCode** (integer) - Optional - The HTTP status code to return.
  - **BodyAsJson** (object) - Optional - The response body as JSON.
  - **BodyAsJsonIndented** (boolean) - Optional - Whether to indent the JSON response.
  - **UseTransformer** (boolean) - Optional - Whether to use a response transformer.
  - **Headers** (object) - Optional - Response headers.

### Request Example
```json
{
  "Request": {
    "Path": {
      "Matchers": []
    },
    "Methods": [
      "get"
    ],
    "Headers": [],
    "Cookies": [],
    "Params": [
      {
        "Name": "start",
        "Values": []
      }
    ],
    "Body": {}
  },
  "Response": {
    "StatusCode": 205,
    "BodyAsJson": { "msg": "Hello world!!" },
    "BodyAsJsonIndented": true,
    "UseTransformer": true,
    "Headers": {
      "Transformed-Postman-Token": "token is {{request.headers.Postman-Token}}",
      "Content-Type": "application/json"
    }
  }
}
```

### Response
#### Success Response (200)
- **(No specific fields defined, typically returns a success status)**

#### Response Example
```json
// Typically an empty success response or a confirmation message
```
```

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

### Enable Proxy and Record Functionality in WireMock.Net

Source: https://wiremock.org/dotnet/settings

Demonstrates how to start a WireMock.Net server with proxy and record functionality enabled. It configures the server URL, admin interface, and specifies detailed settings for proxying and recording, including target URL, mapping saving options, blacklisted items, and web proxy configuration.

```csharp
var server = WireMockServer.Start(new FluentMockServerSettings
{
    Urls = new[] { "http://localhost:9095/" },
    StartAdminInterface = true,
    ProxyAndRecordSettings = new ProxyAndRecordSettings
    {
        Url = "http://www.bbc.com",
        SaveMapping = true,
        SaveMappingToFile = true,
        BlackListedHeaders = new [] { "dnt", "Content-Length" },
        BlackListedCookies = new [] { "c1", "c2" },
        SaveMappingForStatusCodePattern = "2xx",
        AllowAutoRedirect = true,
        WebProxySettings = new WebProxySettings
        {
            UserName = "test",
            Password = "pwd",
            Address = "http://company.proxy"
        },
        UseDefinedRequestMatchers = false,
        AppendGuidToSavedMappingFile = true,
        ReplaceSettings = new ProxyUrlReplaceSettings
        {
            "OldValue" = "old",
            "NewValue" = "new"
        }
    }
});
```

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

### Configure Webhook in C# using WireMock.NET

Source: https://wiremock.org/dotnet/webhook

Demonstrates two C# code options for configuring a webhook with WireMock.NET. The first option uses a Webhook object for detailed request configuration, while the second uses a simplified method signature. Both options attach a webhook to a mocked response.

```csharp
var server = WireMockServer.Start();
server.Given(Request.Create().UsingPost())
    .WithWebhook(new Webhook
    {
        Request = new WebhookRequest
        {
            Url = "https://any-endpoint.com",
            Method = "post",
            BodyData = new BodyData
            {
                BodyAsString = "OK !",
                DetectedBodyType = BodyType.String
            }
        }
    })
    .RespondWith(Response.Create().WithBody("a-response"));


var server2 = WireMockServer.Start();
    server2.Given(Request.Create().UsingPost())
        .WithWebhook("https://any-endpoint.com", "post", null, "OK !", true, TransformerType.Handlebars)
        .RespondWith(Response.Create().WithBody("a-response"));
```

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

### Handlebars.Net JSON Mapping Example

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

Example of a JSON mapping using Handlebars.Net for response templating, including transforming content from a referenced file.

```APIDOC
## GET /bodyasfile_transform123

### Description
Example JSON mapping using Handlebars.Net for response templating, demonstrating how to transform content from a referenced file.

### Method
GET

### Endpoint
/bodyasfile_transform123

### Parameters
#### Query Parameters
- **MyUniqueNumber** (string) - Required - Used in the file path for dynamic response generation.

### Response
#### Success Response (200)
- **Headers** (object) - Content-Type is set to application/xml.
- **BodyAsFile** (string) - Path to the XML file to be transformed and returned.

#### Response Example
```xml
<response>
  <message>Transformed content based on query parameter</message>
</response>
```
```
Tokens:
Raw