1.5.30

Bump System.Linq.Dynamic.Core (#963 )
Bumps [System.Linq.Dynamic.Core](https://github.com/zzzprojects/System.Linq.Dynamic.Core) from 1.2.23 to 1.3.0. - [Release notes](https://github.com/zzzprojects/System.Linq.Dynamic.Core/releases) - [Changelog](https://github.com/zzzprojects/System.Linq.Dynamic.Core/blob/master/CHANGELOG.md) - [Commits](https://github.com/zzzprojects/System.Linq.Dynamic.Core/compare/v1.2.23...v1.3.0) --- updated-dependencies: - dependency-name: System.Linq.Dynamic.Core dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
2026-01-14 22:33:35 +01:00 · 2023-06-28 08:12:10 +02:00 · 2023-06-28 07:58:03 +02:00 · 2023-06-28 07:57:50 +02:00 · 2023-06-27 22:31:14 +02:00 · 2023-06-23 15:20:57 +02:00
49 changed files with 1481 additions and 374 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,32 @@
+# 1.5.30 (28 June 2023)
+- [#959](https://github.com/WireMock-Net/WireMock.Net/pull/959) - Fixed logic for FluentAssertions WithHeader [bug] contributed by [StefH](https://github.com/StefH)
+- [#961](https://github.com/WireMock-Net/WireMock.Net/pull/961) - Add unit-test for Param MatcherModel LinqMatcher [test] contributed by [StefH](https://github.com/StefH)
+- [#962](https://github.com/WireMock-Net/WireMock.Net/pull/962) - Bump System.Linq.Dynamic.Core from 1.2.23 to 1.3.0 in /examples/WireMock.Net.Console.Net472.Classic [dependencies] contributed by [dependabot[bot]](https://github.com/apps/dependabot)
+- [#963](https://github.com/WireMock-Net/WireMock.Net/pull/963) - Bump System.Linq.Dynamic.Core from 1.2.23 to 1.3.0 in /examples/WireMock.Net.StandAlone.Net461 [dependencies] contributed by [dependabot[bot]](https://github.com/apps/dependabot)
+- [#958](https://github.com/WireMock-Net/WireMock.Net/issues/958) - [FluentAssertions] Should().HaveReceivedACall().WithHeader() only checks the first header with the matching key. [bug]
+
+# 1.5.29 (22 June 2023)
+- [#954](https://github.com/WireMock-Net/WireMock.Net/pull/954) - Support setting WireMockServerSettings via Environment [feature] contributed by [StefH](https://github.com/StefH)
+- [#955](https://github.com/WireMock-Net/WireMock.Net/pull/955) - Fix some SonarCloud issues [refactor] contributed by [StefH](https://github.com/StefH)
+- [#953](https://github.com/WireMock-Net/WireMock.Net/issues/953) - How to use environment variable [feature]
+
+# 1.5.28 (11 June 2023)
+- [#948](https://github.com/WireMock-Net/WireMock.Net/pull/948) - WireMock.Net.Testcontainers [feature] contributed by [StefH](https://github.com/StefH)
+- [#951](https://github.com/WireMock-Net/WireMock.Net/pull/951) - Allow setting the Content-Length header for a HTTP method HEAD [feature] contributed by [StefH](https://github.com/StefH)
+
+# 1.5.27 (03 June 2023)
+- [#946](https://github.com/WireMock-Net/WireMock.Net/pull/946) - Add warning logging when sending a request to a Webhook does not return status 200 [feature] contributed by [StefH](https://github.com/StefH)
+- [#949](https://github.com/WireMock-Net/WireMock.Net/pull/949) - Add &quot;.NET Framework 4.7&quot; to WireMock.Net.FluentAssertions [feature] contributed by [StefH](https://github.com/StefH)
+- [#928](https://github.com/WireMock-Net/WireMock.Net/issues/928) - TypeLoadException when using WithHeader method. [bug]
+- [#945](https://github.com/WireMock-Net/WireMock.Net/issues/945) - Webhook logging [feature]
+
+# 1.5.26 (25 May 2023)
+- [#938](https://github.com/WireMock-Net/WireMock.Net/pull/938) - Add more unitests for CSharpFormatter utils [test] contributed by [StefH](https://github.com/StefH)
+- [#939](https://github.com/WireMock-Net/WireMock.Net/pull/939) - WireMockMiddleware should use HandleRequestsSynchronously correctly [bug] contributed by [StefH](https://github.com/StefH)
+- [#940](https://github.com/WireMock-Net/WireMock.Net/pull/940) - Code generator improvements contributed by [cezarypiatek](https://github.com/cezarypiatek)
+- [#942](https://github.com/WireMock-Net/WireMock.Net/pull/942) - Add GetParameter method to IRequestMessage [feature] contributed by [StefH](https://github.com/StefH)
+- [#941](https://github.com/WireMock-Net/WireMock.Net/issues/941) - RequestMessage.GetParameter method missing from IRequestMessage interface [feature]
+
 # 1.5.25 (13 May 2023)
 - [#934](https://github.com/WireMock-Net/WireMock.Net/pull/934) - Code generator improvements [feature] contributed by [cezarypiatek](https://github.com/cezarypiatek)

--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -4,7 +4,7 @@
    </PropertyGroup>

    <PropertyGroup>
-        <VersionPrefix>1.5.25</VersionPrefix>
+        <VersionPrefix>1.5.30</VersionPrefix>
        <PackageIcon>WireMock.Net-Logo.png</PackageIcon>
        <PackageProjectUrl>https://github.com/WireMock-Net/WireMock.Net</PackageProjectUrl>
        <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>
--- a/Generate-ReleaseNotes.cmd
+++ b/Generate-ReleaseNotes.cmd
@@ -1,6 +1,6 @@
 rem https://github.com/StefH/GitHubReleaseNotes

-SET version=1.5.25
+SET version=1.5.30

 GitHubReleaseNotes --output CHANGELOG.md --skip-empty-releases --exclude-labels question invalid doc duplicate --version %version% --token %GH_TOKEN%

--- a/PackageReleaseNotes.txt
+++ b/PackageReleaseNotes.txt
@@ -1,4 +1,8 @@
-# 1.5.25 (13 May 2023)
- #934 Code generator improvements [feature]
+# 1.5.30 (28 June 2023)
+- #959 Fixed logic for FluentAssertions WithHeader [bug]
+- #961 Add unit-test for Param MatcherModel LinqMatcher [test]
+- #962 Bump System.Linq.Dynamic.Core from 1.2.23 to 1.3.0 in /examples/WireMock.Net.Console.Net472.Classic [dependencies]
+- #963 Bump System.Linq.Dynamic.Core from 1.2.23 to 1.3.0 in /examples/WireMock.Net.StandAlone.Net461 [dependencies]
+- #958 [FluentAssertions] Should().HaveReceivedACall().WithHeader() only checks the first header with the matching key. [bug]

 The full release notes can be found here: https://github.com/WireMock-Net/WireMock.Net/blob/master/CHANGELOG.md
--- a/README.md
+++ b/README.md
@@ -22,7 +22,7 @@ For more info, see also this WIKI page: [What is WireMock.Net](https://github.co
 | | |
 | --- | --- |
 | ***Project*** | &nbsp; |
-| &nbsp;&nbsp;**Chat** | [![Gitter](https://img.shields.io/gitter/room/wiremock_dotnet/Lobby.svg)](https://gitter.im/wiremock_dotnet/Lobby) |
+| &nbsp;&nbsp;**Chat** | [![Slack](https://badgen.net/badge/icon/slack?icon=slack&label)](https://slack.wiremock.org/) [![Gitter](https://img.shields.io/gitter/room/wiremock_dotnet/Lobby.svg)](https://gitter.im/wiremock_dotnet/Lobby) |
 | &nbsp;&nbsp;**Issues** | [![GitHub issues](https://img.shields.io/github/issues/WireMock-Net/WireMock.Net.svg)](https://github.com/WireMock-Net/WireMock.Net/issues) |
 | | |
 | ***Quality*** | &nbsp; |
@@ -42,6 +42,7 @@ For more info, see also this WIKI page: [What is WireMock.Net](https://github.co
 | &nbsp;&nbsp;**WireMock.Net.OpenApiParser** | [![NuGet Badge WireMock.Net.OpenApiParser](https://buildstats.info/nuget/WireMock.Net.OpenApiParser)](https://www.nuget.org/packages/WireMock.Net.OpenApiParser) | [![MyGet Badge WireMock.Net.OpenApiParser](https://buildstats.info/myget/wiremock-net/WireMock.Net.OpenApiParser?includePreReleases=true)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net.OpenApiParser)
 | &nbsp;&nbsp;**WireMock.Net.RestClient** | [![NuGet Badge WireMock.Net.RestClient](https://buildstats.info/nuget/WireMock.Net.RestClient)](https://www.nuget.org/packages/WireMock.Net.RestClient) | [![MyGet Badge WireMock.Net.RestClient](https://buildstats.info/myget/wiremock-net/WireMock.Net.RestClient?includePreReleases=true)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net.RestClient)
 | &nbsp;&nbsp;**WireMock.Net.xUnit** | [![NuGet Badge WireMock.Net.xUnit](https://buildstats.info/nuget/WireMock.Net.xUnit)](https://www.nuget.org/packages/WireMock.Net.xUnit) | [![MyGet Badge WireMock.Net.xUnit](https://buildstats.info/myget/wiremock-net/WireMock.Net.xUnit?includePreReleases=true)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net.xUnit)
+| &nbsp;&nbsp;**WireMock.Net.Testcontainers** | [![NuGet Badge WireMock.Net.Testcontainers](https://buildstats.info/nuget/WireMock.Net.Testcontainers)](https://www.nuget.org/packages/WireMock.Net.Testcontainers) | [![MyGet Badge WireMock.Net.Testcontainers](https://buildstats.info/myget/wiremock-net/WireMock.Net.Testcontainers?includePreReleases=true)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net.Testcontainers)
 | &nbsp;&nbsp;**WireMock.Org.RestClient** | [![NuGet Badge WireMock.Org.RestClient](https://buildstats.info/nuget/WireMock.Org.RestClient)](https://www.nuget.org/packages/WireMock.Org.RestClient) | [![MyGet Badge WireMock.Org.RestClient](https://buildstats.info/myget/wiremock-net/WireMock.Org.RestClient?includePreReleases=true)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Org.RestClient)


@@ -68,13 +69,15 @@ WireMock.Net can be used in several ways:
 You can use your favorite test framework and use WireMock within your tests, see
 [Wiki : UnitTesting](https://github.com/StefH/WireMock.Net/wiki/Using-WireMock-in-UnitTests).

+### Unit/Integration Testing using Testcontainers.DotNet
+You can use [Wiki : WireMock.Net.Testcontainers](https://github.com/WireMock-Net/WireMock.Net/wiki/Using-WireMock.Net.Testcontainers) to build a WireMock.Net Docker container which can be used in Unit/Integration testing.
+
 ### As a dotnet tool
 It's simple to install WireMock.Net as (global) dotnet tool, see [Wiki : dotnet tool](https://github.com/StefH/WireMock.Net/wiki/WireMock-as-dotnet-tool).

 ### As standalone process / console application
 This is quite straight forward to launch a mock server within a console application, see [Wiki : Standalone Process](https://github.com/StefH/WireMock.Net/wiki/WireMock-as-a-standalone-process).

-
 ### As a Windows Service
 You can also run WireMock.Net as a Windows Service, follow this [WireMock-as-a-Windows-Service](https://github.com/WireMock-Net/WireMock.Net/wiki/WireMock-as-a-Windows-Service).

--- a/Solution.sln
+++ b/Solution.sln
@@ -111,6 +111,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WireMockAzureQueueExample",
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WireMockAzureQueueProxy", "examples\WireMockAzureQueueProxy\WireMockAzureQueueProxy.csproj", "{ADB557D8-D66B-4387-912B-3F73E290B478}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WireMock.Net.Testcontainers", "src\WireMock.Net.Testcontainers\WireMock.Net.Testcontainers.csproj", "{12B016A5-9D8B-4EFE-96C2-CA51BE43367D}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WireMock.Net.TestcontainersExample", "examples\WireMock.Net.TestcontainersExample\WireMock.Net.TestcontainersExample.csproj", "{56A38798-C48B-4A4A-B805-071E05C02CE1}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -265,6 +269,14 @@ Global
 		{ADB557D8-D66B-4387-912B-3F73E290B478}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{ADB557D8-D66B-4387-912B-3F73E290B478}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{ADB557D8-D66B-4387-912B-3F73E290B478}.Release|Any CPU.Build.0 = Release|Any CPU
+		{12B016A5-9D8B-4EFE-96C2-CA51BE43367D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{12B016A5-9D8B-4EFE-96C2-CA51BE43367D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{12B016A5-9D8B-4EFE-96C2-CA51BE43367D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{12B016A5-9D8B-4EFE-96C2-CA51BE43367D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{56A38798-C48B-4A4A-B805-071E05C02CE1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{56A38798-C48B-4A4A-B805-071E05C02CE1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{56A38798-C48B-4A4A-B805-071E05C02CE1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{56A38798-C48B-4A4A-B805-071E05C02CE1}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -309,6 +321,8 @@ Global
 		{7C2A9DE8-C89F-4841-9058-6B9BF81E5E34} = {985E0ADB-D4B4-473A-AA40-567E279B7946}
 		{BAA9EC2A-874B-45CE-8E51-A73622DC7F3D} = {985E0ADB-D4B4-473A-AA40-567E279B7946}
 		{ADB557D8-D66B-4387-912B-3F73E290B478} = {985E0ADB-D4B4-473A-AA40-567E279B7946}
+		{12B016A5-9D8B-4EFE-96C2-CA51BE43367D} = {8F890C6F-9ACC-438D-928A-AD61CDA862F2}
+		{56A38798-C48B-4A4A-B805-071E05C02CE1} = {985E0ADB-D4B4-473A-AA40-567E279B7946}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {DC539027-9852-430C-B19F-FD035D018458}
--- a/Solution.sln.DotSettings
+++ b/Solution.sln.DotSettings
@@ -10,6 +10,7 @@
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=IP/@EntryIndexedValue">IP</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=MD/@EntryIndexedValue">MD5</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=OPTIONS/@EntryIndexedValue">OPTIONS</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=OS/@EntryIndexedValue">OS</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=PATCH/@EntryIndexedValue">PATCH</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=POST/@EntryIndexedValue">POST</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=PUT/@EntryIndexedValue">PUT</s:String>
@@ -32,6 +33,7 @@
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Raml/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=randomizer/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Scriban/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=sheyenrath/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Sigil/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Stef/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=templated/@EntryIndexedValue">True</s:Boolean>
--- a/examples/WireMock.Net.Console.Net472.Classic/packages.config
+++ b/examples/WireMock.Net.Console.Net472.Classic/packages.config
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <packages>
  <package id="AnyOf" version="0.3.0" targetFramework="net472" />
  <package id="Fare" version="2.2.1" targetFramework="net472" />
@@ -138,7 +138,7 @@
  <package id="System.Diagnostics.DiagnosticSource" version="4.5.0" targetFramework="net472" />
  <package id="System.IdentityModel.Tokens.Jwt" version="6.25.0" targetFramework="net472" />
  <package id="System.IO.Pipelines" version="4.5.3" targetFramework="net472" />
-  <package id="System.Linq.Dynamic.Core" version="1.2.23" targetFramework="net472" />
+  <package id="System.Linq.Dynamic.Core" version="1.3.0" targetFramework="net472" />
  <package id="System.Memory" version="4.5.4" targetFramework="net472" />
  <package id="System.Numerics.Vectors" version="4.5.0" targetFramework="net472" />
  <package id="System.Reflection.Metadata" version="1.6.0" targetFramework="net472" />
--- a/examples/WireMock.Net.StandAlone.NETCoreApp/Program.cs
+++ b/examples/WireMock.Net.StandAlone.NETCoreApp/Program.cs
@@ -29,7 +29,7 @@ static class Program

        XmlConfigurator.Configure(LogRepository, new FileInfo("log4net.config"));

-        if (!WireMockServerSettingsParser.TryParseArguments(args, out var settings, new WireMockLog4NetLogger()))
+        if (!WireMockServerSettingsParser.TryParseArguments(args, Environment.GetEnvironmentVariables(), out var settings, new WireMockLog4NetLogger()))
        {
            return;
        }
--- a/examples/WireMock.Net.StandAlone.Net461/packages.config
+++ b/examples/WireMock.Net.StandAlone.Net461/packages.config
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <packages>
  <package id="Handlebars.Net" version="2.1.2" targetFramework="net461" />
  <package id="Microsoft.AspNet.WebApi.Client" version="5.2.9" targetFramework="net461" />
@@ -68,7 +68,7 @@
  <package id="System.ComponentModel.Annotations" version="4.5.0" targetFramework="net461" />
  <package id="System.Diagnostics.DiagnosticSource" version="4.5.1" targetFramework="net461" />
  <package id="System.IO.Pipelines" version="4.5.3" targetFramework="net461" />
-  <package id="System.Linq.Dynamic.Core" version="1.2.23" targetFramework="net461" />
+  <package id="System.Linq.Dynamic.Core" version="1.3.0" targetFramework="net461" />
  <package id="System.Memory" version="4.5.4" targetFramework="net461" />
  <package id="System.Numerics.Vectors" version="4.5.0" targetFramework="net461" />
  <package id="System.Reflection.Metadata" version="1.6.0" targetFramework="net461" />
--- a/examples/WireMock.Net.TestcontainersExample/Program.cs
+++ b/examples/WireMock.Net.TestcontainersExample/Program.cs
@@ -0,0 +1,43 @@
+using Newtonsoft.Json;
+using Testcontainers.MsSql;
+using WireMock.Net.Testcontainers;
+
+namespace WireMock.Net.TestcontainersExample;
+
+internal class Program
+{
+    private static async Task Main(string[] args)
+    {
+        var container = new WireMockContainerBuilder()
+            .WithAdminUserNameAndPassword("x", "y")
+            .WithMappings(@"C:\Dev\GitHub\WireMock.Net\examples\WireMock.Net.Console.NET6\__admin\mappings")
+            .WithWatchStaticMappings(true)
+            .WithAutoRemove(true)
+            .WithCleanUp(true)
+            .Build();
+
+        await container.StartAsync().ConfigureAwait(false);
+
+        var logs = await container.GetLogsAsync(DateTime.Now.AddDays(-1)).ConfigureAwait(false);
+        Console.WriteLine("logs = " + logs.Stdout);
+
+        var restEaseApiClient = container.CreateWireMockAdminClient();
+
+        var settings = await restEaseApiClient.GetSettingsAsync();
+        Console.WriteLine("settings = " + JsonConvert.SerializeObject(settings, Formatting.Indented));
+
+        var mappings = await restEaseApiClient.GetMappingsAsync();
+        Console.WriteLine("mappings = " + JsonConvert.SerializeObject(mappings, Formatting.Indented));
+
+        var client = container.CreateClient();
+        var result = await client.GetStringAsync("/static/mapping");
+        Console.WriteLine("result = " + result);
+
+        await container.StopAsync();
+
+        var sql = new MsSqlBuilder()
+            .WithAutoRemove(true)
+            .WithCleanUp(true)
+            .Build();
+    }
+}
--- a/examples/WireMock.Net.TestcontainersExample/WireMock.Net.TestcontainersExample.csproj
+++ b/examples/WireMock.Net.TestcontainersExample/WireMock.Net.TestcontainersExample.csproj
@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Testcontainers.MsSql" Version="3.2.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\WireMock.Net.Testcontainers\WireMock.Net.Testcontainers.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="873d495f-940e-4b86-a1f4-4f0fc7be8b8b.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+</Project>
--- a/src/WireMock.Net.Abstractions/IRequestMessage.cs
+++ b/src/WireMock.Net.Abstractions/IRequestMessage.cs
@@ -143,6 +143,14 @@ public interface IRequestMessage
    /// </summary>
    string Origin { get; }

+    /// <summary>
+    /// Get a query parameter.
+    /// </summary>
+    /// <param name="key">The key.</param>
+    /// <param name="ignoreCase">Defines if the key should be matched using case-ignore.</param>
+    /// <returns>The query parameter value as WireMockList or null when not found.</returns>
+    WireMockList<string>? GetParameter(string key, bool ignoreCase = false);
+
 #if NETSTANDARD1_3_OR_GREATER || NET461
    /// <summary>
    /// Gets the connection's client certificate
--- a/src/WireMock.Net.FluentAssertions/Assertions/WireMockAssertions.cs
+++ b/src/WireMock.Net.FluentAssertions/Assertions/WireMockAssertions.cs
@@ -149,15 +149,15 @@ public class WireMockAssertions

        using (new AssertionScope($"header \"{expectedKey}\" from requests sent with value(s)"))
        {
-            var headerValues = _headers.First(h => h.Key == expectedKey).Value;
+            var matchingHeaderValues = _headers.Where(h => h.Key == expectedKey).SelectMany(h => h.Value.ToArray()).ToArray();

            if (expectedValues.Length == 1)
            {
-                headerValues.Should().Contain(expectedValues.First(), because, becauseArgs);
+                matchingHeaderValues.Should().Contain(expectedValues.First(), because, becauseArgs);
            }
            else
            {
-                var trimmedHeaderValues = string.Join(",", headerValues.Select(x => x)).Split(',').Select(x => x.Trim()).ToList();
+                var trimmedHeaderValues = string.Join(",", matchingHeaderValues.Select(x => x)).Split(',').Select(x => x.Trim()).ToList();
                foreach (var expectedValue in expectedValues)
                {
                    trimmedHeaderValues.Should().Contain(expectedValue, because, becauseArgs);
--- a/src/WireMock.Net.FluentAssertions/WireMock.Net.FluentAssertions.csproj
+++ b/src/WireMock.Net.FluentAssertions/WireMock.Net.FluentAssertions.csproj
@@ -1,49 +1,49 @@
 <Project Sdk="Microsoft.NET.Sdk">

-	<PropertyGroup>
-		<Description>FluentAssertions extensions for WireMock.Net</Description>
-		<AssemblyTitle>WireMock.Net.FluentAssertions</AssemblyTitle>
-		<Authors>Mahmoud Ali;Stef Heyenrath</Authors>
-		<TargetFrameworks>net451;netstandard1.3;netstandard2.0;netstandard2.1</TargetFrameworks>
-		<GenerateDocumentationFile>true</GenerateDocumentationFile>
-		<AssemblyName>WireMock.Net.FluentAssertions</AssemblyName>
-		<PackageId>WireMock.Net.FluentAssertions</PackageId>
-		<PackageTags>wiremock;FluentAssertions;UnitTest;Assert;Assertions</PackageTags>
-		<RootNamespace>WireMock.FluentAssertions</RootNamespace>
-		<ProjectGuid>{B6269AAC-170A-4346-8B9A-579DED3D9A95}</ProjectGuid>
-		<PublishRepositoryUrl>true</PublishRepositoryUrl>
-		<AllowedOutputExtensionsInPackageBuildOutputFolder>$(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb</AllowedOutputExtensionsInPackageBuildOutputFolder>
-		<EmbedUntrackedSources>true</EmbedUntrackedSources>
-		<AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
-		<GenerateBindingRedirectsOutputType>true</GenerateBindingRedirectsOutputType>
-		<CodeAnalysisRuleSet>../WireMock.Net/WireMock.Net.ruleset</CodeAnalysisRuleSet>
-		<SignAssembly>true</SignAssembly>
-		<AssemblyOriginatorKeyFile>../WireMock.Net/WireMock.Net.snk</AssemblyOriginatorKeyFile>
-		<!--<DelaySign>true</DelaySign>-->
-		<PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
-    <PackageLicenseExpression>MIT</PackageLicenseExpression>
-    <LangVersion>10</LangVersion>
-	</PropertyGroup>
+    <PropertyGroup>
+        <Description>FluentAssertions extensions for WireMock.Net</Description>
+        <AssemblyTitle>WireMock.Net.FluentAssertions</AssemblyTitle>
+        <Authors>Mahmoud Ali;Stef Heyenrath</Authors>
+        <TargetFrameworks>net451;net47;netstandard1.3;netstandard2.0;netstandard2.1</TargetFrameworks>
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+        <AssemblyName>WireMock.Net.FluentAssertions</AssemblyName>
+        <PackageId>WireMock.Net.FluentAssertions</PackageId>
+        <PackageTags>wiremock;FluentAssertions;UnitTest;Assert;Assertions</PackageTags>
+        <RootNamespace>WireMock.FluentAssertions</RootNamespace>
+        <ProjectGuid>{B6269AAC-170A-4346-8B9A-579DED3D9A95}</ProjectGuid>
+        <PublishRepositoryUrl>true</PublishRepositoryUrl>
+        <AllowedOutputExtensionsInPackageBuildOutputFolder>$(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb</AllowedOutputExtensionsInPackageBuildOutputFolder>
+        <EmbedUntrackedSources>true</EmbedUntrackedSources>
+        <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+        <GenerateBindingRedirectsOutputType>true</GenerateBindingRedirectsOutputType>
+        <CodeAnalysisRuleSet>../WireMock.Net/WireMock.Net.ruleset</CodeAnalysisRuleSet>
+        <SignAssembly>true</SignAssembly>
+        <AssemblyOriginatorKeyFile>../WireMock.Net/WireMock.Net.snk</AssemblyOriginatorKeyFile>
+        <!--<DelaySign>true</DelaySign>-->
+        <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
+        <PackageLicenseExpression>MIT</PackageLicenseExpression>
+        <LangVersion>10</LangVersion>
+    </PropertyGroup>

-	<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
-		<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-	</PropertyGroup>
+    <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
+        <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+    </PropertyGroup>

-	<ItemGroup>
-		<PackageReference Include="JetBrains.Annotations" Version="2022.3.1" PrivateAssets="All" />
-		<PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All" />
-	</ItemGroup>
+    <ItemGroup>
+        <PackageReference Include="JetBrains.Annotations" Version="2022.3.1" PrivateAssets="All" />
+        <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All" />
+    </ItemGroup>

-  <ItemGroup Condition="'$(TargetFramework)' == 'net451' or '$(TargetFramework)' == 'netstandard1.3'">
-    <PackageReference Include="FluentAssertions" Version="5.10.3" />
-  </ItemGroup>
+    <ItemGroup Condition="'$(TargetFramework)' == 'net451' or '$(TargetFramework)' == 'netstandard1.3'">
+        <PackageReference Include="FluentAssertions" Version="5.10.3" />
+    </ItemGroup>

-  <ItemGroup Condition="'$(TargetFramework)' != 'net451' and '$(TargetFramework)' != 'netstandard1.3'">
-    <PackageReference Include="FluentAssertions" Version="6.5.1" />
-  </ItemGroup>
+    <ItemGroup Condition="'$(TargetFramework)' != 'net451' and '$(TargetFramework)' != 'netstandard1.3'">
+        <PackageReference Include="FluentAssertions" Version="6.5.1" />
+    </ItemGroup>

-	<ItemGroup>
-	  <ProjectReference Include="..\WireMock.Net.Abstractions\WireMock.Net.Abstractions.csproj" />
-	</ItemGroup>
+    <ItemGroup>
+        <ProjectReference Include="..\WireMock.Net.Abstractions\WireMock.Net.Abstractions.csproj" />
+    </ItemGroup>

 </Project>
--- a/src/WireMock.Net.OpenApiParser/Mappers/OpenApiPathsMapper.cs
+++ b/src/WireMock.Net.OpenApiParser/Mappers/OpenApiPathsMapper.cs
@@ -320,14 +320,14 @@ internal class OpenApiPathsMapper
        var mappedHeaders = headers?.ToDictionary(
            item => item.Key,
            _ => GetExampleMatcherModel(null, _settings.HeaderPatternToUse).Pattern!
-        );
+        ) ?? new Dictionary<string, object>();

        if (!string.IsNullOrEmpty(responseContentType))
        {
            mappedHeaders.TryAdd(HeaderContentType, responseContentType!);
        }

-        return mappedHeaders?.Keys.Any() == true ? mappedHeaders : null;
+        return mappedHeaders.Keys.Any() ? mappedHeaders : null;
    }

    private IList<ParamModel>? MapQueryParameters(IEnumerable<OpenApiParameter> queryParameters)
--- a/src/WireMock.Net.OpenApiParser/WireMockOpenApiParser.cs
+++ b/src/WireMock.Net.OpenApiParser/WireMockOpenApiParser.cs
@@ -47,9 +47,9 @@ public class WireMockOpenApiParser : IWireMockOpenApiParser

    /// <inheritdoc />
    [PublicAPI]
-    public IReadOnlyList<MappingModel> FromDocument(OpenApiDocument openApiDocument, WireMockOpenApiParserSettings? settings = null)
+    public IReadOnlyList<MappingModel> FromDocument(OpenApiDocument document, WireMockOpenApiParserSettings? settings = null)
    {
-        return new OpenApiPathsMapper(settings ?? new WireMockOpenApiParserSettings()).ToMappingModels(openApiDocument.Paths, openApiDocument.Servers);
+        return new OpenApiPathsMapper(settings ?? new WireMockOpenApiParserSettings()).ToMappingModels(document.Paths, document.Servers);
    }

    /// <inheritdoc  />
--- a/src/WireMock.Net.StandAlone/StandAloneApp.cs
+++ b/src/WireMock.Net.StandAlone/StandAloneApp.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Reflection;
@@ -24,7 +25,7 @@ public static class StandAloneApp
    [PublicAPI]
    public static WireMockServer Start(WireMockServerSettings settings)
    {
-        Guard.NotNull(settings, nameof(settings));
+        Guard.NotNull(settings);

        var server = WireMockServer.Start(settings);

@@ -42,7 +43,7 @@ public static class StandAloneApp
    [PublicAPI]
    public static WireMockServer Start(string[] args, IWireMockLogger? logger = null)
    {
-        Guard.NotNull(args, nameof(args));
+        Guard.NotNull(args);

        if (TryStart(args, out var server, logger))
        {
@@ -61,9 +62,9 @@ public static class StandAloneApp
    [PublicAPI]
    public static bool TryStart(string[] args, [NotNullWhen(true)] out WireMockServer? server, IWireMockLogger? logger = null)
    {
-        Guard.NotNull(args, nameof(args));
+        Guard.NotNull(args);

-        if (WireMockServerSettingsParser.TryParseArguments(args, out var settings, logger))
+        if (WireMockServerSettingsParser.TryParseArguments(args, Environment.GetEnvironmentVariables(), out var settings, logger))
        {
            settings.Logger?.Info("Version [{0}]", Version);
            settings.Logger?.Debug("Server arguments [{0}]", string.Join(", ", args.Select(a => $"'{a}'")));
--- a/src/WireMock.Net.Testcontainers/Models/ContainerInfo.cs
+++ b/src/WireMock.Net.Testcontainers/Models/ContainerInfo.cs
@@ -0,0 +1,7 @@
+namespace WireMock.Net.Testcontainers.Models;
+
+internal record ContainerInfo
+(
+    string Image,
+    string MappingsPath
+);
--- a/src/WireMock.Net.Testcontainers/WireMock.Net.Testcontainers.csproj
+++ b/src/WireMock.Net.Testcontainers/WireMock.Net.Testcontainers.csproj
@@ -0,0 +1,36 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <Description>A fluent testcontainer builder for the Docker version of WireMock.Net</Description>
+        <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+        <PackageTags>wiremock;docker;testcontainer;testcontainers</PackageTags>
+        <ProjectGuid>{12B016A5-9D8B-4EFE-96C2-CA51BE43367D}</ProjectGuid>
+        <PublishRepositoryUrl>true</PublishRepositoryUrl>
+        <CodeAnalysisRuleSet>../WireMock.Net/WireMock.Net.ruleset</CodeAnalysisRuleSet>
+        <SignAssembly>true</SignAssembly>
+        <AssemblyOriginatorKeyFile>../WireMock.Net/WireMock.Net.snk</AssemblyOriginatorKeyFile>
+        <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
+        <PackageLicenseExpression>MIT</PackageLicenseExpression>
+        <LangVersion>10</LangVersion>
+    </PropertyGroup>
+
+    <PropertyGroup Condition="'$(Configuration)' == 'Release'">
+        <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="IsExternalInit" Version="1.0.3">
+          <PrivateAssets>all</PrivateAssets>
+          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <PackageReference Include="Microsoft.AspNet.WebApi.Client" Version="5.2.9" />
+        <PackageReference Include="Stef.Validation" Version="0.1.1" />
+        <PackageReference Include="Testcontainers" Version="3.2.0" />
+        <PackageReference Include="JetBrains.Annotations" VersionOverride="2022.3.1" PrivateAssets="All" Version="2022.3.1" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\WireMock.Net.RestClient\WireMock.Net.RestClient.csproj" />
+    </ItemGroup>
+</Project>
--- a/src/WireMock.Net.Testcontainers/WireMockConfiguration.cs
+++ b/src/WireMock.Net.Testcontainers/WireMockConfiguration.cs
@@ -0,0 +1,66 @@
+using Docker.DotNet.Models;
+using DotNet.Testcontainers.Builders;
+using DotNet.Testcontainers.Configurations;
+using JetBrains.Annotations;
+
+namespace WireMock.Net.Testcontainers;
+
+/// <inheritdoc cref="ContainerConfiguration" />
+[PublicAPI]
+public sealed class WireMockConfiguration : ContainerConfiguration
+{
+#pragma warning disable CS1591
+    public string? Username { get; }
+
+    public string? Password { get; }
+
+    public bool HasBasicAuthentication => !string.IsNullOrEmpty(Username) && !string.IsNullOrEmpty(Password);
+
+    public WireMockConfiguration(
+        string? username = null,
+        string? password = null
+    )
+    {
+        Username = username;
+        Password = password;
+    }
+#pragma warning restore CS1591
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="WireMockConfiguration" /> class.
+    /// </summary>
+    /// <param name="resourceConfiguration">The Docker resource configuration.</param>
+    public WireMockConfiguration(IResourceConfiguration<CreateContainerParameters> resourceConfiguration) : base(resourceConfiguration)
+    {
+        // Passes the configuration upwards to the base implementations to create an updated immutable copy.
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="WireMockConfiguration" /> class.
+    /// </summary>
+    /// <param name="resourceConfiguration">The Docker resource configuration.</param>
+    public WireMockConfiguration(IContainerConfiguration resourceConfiguration) : base(resourceConfiguration)
+    {
+        // Passes the configuration upwards to the base implementations to create an updated immutable copy.
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="WireMockConfiguration" /> class.
+    /// </summary>
+    /// <param name="resourceConfiguration">The Docker resource configuration.</param>
+    public WireMockConfiguration(WireMockConfiguration resourceConfiguration) : this(new WireMockConfiguration(), resourceConfiguration)
+    {
+        // Passes the configuration upwards to the base implementations to create an updated immutable copy.
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="WireMockConfiguration" /> class.
+    /// </summary>
+    /// <param name="oldValue">The old Docker resource configuration.</param>
+    /// <param name="newValue">The new Docker resource configuration.</param>
+    public WireMockConfiguration(WireMockConfiguration oldValue, WireMockConfiguration newValue) : base(oldValue, newValue)
+    {
+        Username = BuildConfiguration.Combine(oldValue.Username, newValue.Username);
+        Password = BuildConfiguration.Combine(oldValue.Password, newValue.Password);
+    }
+}
--- a/src/WireMock.Net.Testcontainers/WireMockContainer.cs
+++ b/src/WireMock.Net.Testcontainers/WireMockContainer.cs
@@ -0,0 +1,110 @@
+using System;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Text;
+using DotNet.Testcontainers.Containers;
+using JetBrains.Annotations;
+using Microsoft.Extensions.Logging;
+using RestEase;
+using Stef.Validation;
+using WireMock.Client;
+
+namespace WireMock.Net.Testcontainers;
+
+/// <summary>
+/// A container for running WireMock in a docker environment.
+/// </summary>
+public sealed class WireMockContainer : DockerContainer
+{
+    internal const int ContainerPort = 80;
+
+    private readonly WireMockConfiguration _configuration;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="WireMockContainer" /> class.
+    /// </summary>
+    /// <param name="configuration">The container configuration.</param>
+    /// <param name="logger">The logger.</param>
+    public WireMockContainer(WireMockConfiguration configuration, ILogger logger) : base(configuration, logger)
+    {
+        _configuration = Guard.NotNull(configuration);
+    }
+
+    /// <summary>
+    /// Gets the public Url.
+    /// </summary>
+    [PublicAPI]
+    public string GetPublicUrl() => GetPublicUri().ToString();
+
+    /// <summary>
+    /// Create a RestEase Admin client which can be used to call the admin REST endpoint.
+    /// </summary>
+    /// <returns>A <see cref="IWireMockAdminApi"/></returns>
+    [PublicAPI]
+    public IWireMockAdminApi CreateWireMockAdminClient()
+    {
+        ValidateIfRunning();
+
+        var api = RestClient.For<IWireMockAdminApi>(GetPublicUri());
+
+        if (_configuration.HasBasicAuthentication)
+        {
+            api.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.ASCII.GetBytes($"{_configuration.Username}:{_configuration.Password}")));
+        }
+
+        return api;
+    }
+
+    /// <summary>
+    /// Create a <see cref="HttpClient"/> which can be used to call this instance.
+    /// <param name="handlers">
+    /// An ordered list of System.Net.Http.DelegatingHandler instances to be invoked
+    /// as an System.Net.Http.HttpRequestMessage travels from the System.Net.Http.HttpClient
+    /// to the network and an System.Net.Http.HttpResponseMessage travels from the network
+    /// back to System.Net.Http.HttpClient. The handlers are invoked in a top-down fashion.
+    /// That is, the first entry is invoked first for an outbound request message but
+    /// last for an inbound response message.
+    /// </param>
+    /// </summary>
+    [PublicAPI]
+    public HttpClient CreateClient(params DelegatingHandler[] handlers)
+    {
+        ValidateIfRunning();
+
+        var client = HttpClientFactory.Create(handlers);
+        client.BaseAddress = GetPublicUri();
+        return client;
+    }
+
+    /// <summary>
+    /// Create a <see cref="HttpClient"/> (one for each URL) which can be used to call this instance.
+    /// <param name="innerHandler">The inner handler represents the destination of the HTTP message channel.</param>
+    /// <param name="handlers">
+    /// An ordered list of System.Net.Http.DelegatingHandler instances to be invoked
+    /// as an System.Net.Http.HttpRequestMessage travels from the System.Net.Http.HttpClient
+    /// to the network and an System.Net.Http.HttpResponseMessage travels from the network
+    /// back to System.Net.Http.HttpClient. The handlers are invoked in a top-down fashion.
+    /// That is, the first entry is invoked first for an outbound request message but
+    /// last for an inbound response message.
+    /// </param>
+    /// </summary>
+    [PublicAPI]
+    public HttpClient CreateClient(HttpMessageHandler innerHandler, params DelegatingHandler[] handlers)
+    {
+        ValidateIfRunning();
+
+        var client = HttpClientFactory.Create(innerHandler, handlers);
+        client.BaseAddress = GetPublicUri();
+        return client;
+    }
+
+    private void ValidateIfRunning()
+    {
+        if (State != TestcontainersStates.Running)
+        {
+            throw new InvalidOperationException("Unable to create HttpClient because the WireMock.Net is not yet running.");
+        }
+    }
+
+    private Uri GetPublicUri() => new UriBuilder(Uri.UriSchemeHttp, Hostname, GetMappedPublicPort(ContainerPort)).Uri;
+}
--- a/src/WireMock.Net.Testcontainers/WireMockContainerBuilder.cs
+++ b/src/WireMock.Net.Testcontainers/WireMockContainerBuilder.cs
@@ -0,0 +1,175 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Docker.DotNet.Models;
+using DotNet.Testcontainers.Builders;
+using DotNet.Testcontainers.Configurations;
+using JetBrains.Annotations;
+using Stef.Validation;
+using WireMock.Net.Testcontainers.Models;
+
+namespace WireMock.Net.Testcontainers;
+
+/// <summary>
+/// An specific fluent Docker container builder for WireMock.Net
+/// </summary>
+public sealed class WireMockContainerBuilder : ContainerBuilder<WireMockContainerBuilder, WireMockContainer, WireMockConfiguration>
+{
+    private readonly Dictionary<bool, ContainerInfo> _info = new()
+    {
+        { false, new ContainerInfo("sheyenrath/wiremock.net:latest", "/app/__admin/mappings") },
+        { true, new ContainerInfo("sheyenrath/wiremock.net-windows:latest", @"c:\app\__admin\mappings") }
+    };
+
+    private const string DefaultLogger = "WireMockConsoleLogger";
+
+    private readonly Lazy<Task<bool>> _isWindowsAsLazy = new(async () =>
+    {
+        using var dockerClientConfig = TestcontainersSettings.OS.DockerEndpointAuthConfig.GetDockerClientConfiguration();
+        using var dockerClient = dockerClientConfig.CreateClient();
+
+        var version = await dockerClient.System.GetVersionAsync();
+        return version.Os.IndexOf("Windows", StringComparison.OrdinalIgnoreCase) > -1;
+    });
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ContainerBuilder" /> class.
+    /// </summary>
+    public WireMockContainerBuilder() : this(new WireMockConfiguration())
+    {
+        DockerResourceConfiguration = Init().DockerResourceConfiguration;
+    }
+
+    /// <summary>
+    /// Automatically set the correct image (Linux or Windows) for WireMock which to create the container.
+    /// </summary>
+    /// <returns>A configured instance of <see cref="WireMockContainerBuilder"/></returns>
+    [PublicAPI]
+    public WireMockContainerBuilder WithImage()
+    {
+        var isWindows = _isWindowsAsLazy.Value.GetAwaiter().GetResult();
+        return WithImage(_info[isWindows].Image);
+    }
+
+    /// <summary>
+    /// Set the admin username and password for the container (basic authentication).
+    /// </summary>
+    /// <param name="username">The admin username.</param>
+    /// <param name="password">The admin password.</param>
+    /// <returns>A configured instance of <see cref="WireMockContainerBuilder"/></returns>
+    public WireMockContainerBuilder WithAdminUserNameAndPassword(string username, string password)
+    {
+        Guard.NotNull(username);
+        Guard.NotNull(password);
+
+        if (string.IsNullOrEmpty(username) && string.IsNullOrEmpty(password))
+        {
+            return this;
+        }
+
+        return Merge(DockerResourceConfiguration, new WireMockConfiguration(username, password))
+            .WithCommand($"--AdminUserName {username}", $"--AdminPassword {password}");
+    }
+
+    /// <summary>
+    /// Use the WireMockNullLogger.
+    /// </summary>
+    /// <returns>A configured instance of <see cref="WireMockContainerBuilder"/></returns>
+    [PublicAPI]
+    public WireMockContainerBuilder WithNullLogger()
+    {
+        return WithCommand("--WireMockLogger WireMockNullLogger");
+    }
+
+    /// <summary>
+    /// Defines if the static mappings should be read at startup (default set to false).
+    /// </summary>
+    /// <returns>A configured instance of <see cref="WireMockContainerBuilder"/></returns>
+    [PublicAPI]
+    public WireMockContainerBuilder WithReadStaticMappings()
+    {
+        return WithCommand("--ReadStaticMappings true");
+    }
+
+    /// <summary>
+    /// Watch the static mapping files + folder for changes when running.
+    /// </summary>
+    /// <returns>A configured instance of <see cref="WireMockContainerBuilder"/></returns>
+    [PublicAPI]
+    public WireMockContainerBuilder WithWatchStaticMappings(bool includeSubDirectories)
+    {
+        return WithCommand("--WatchStaticMappings true").WithCommand($"--WatchStaticMappingsInSubdirectories {includeSubDirectories}");
+    }
+
+    /// <summary>
+    /// Specifies the path for the (static) mapping json files.
+    /// </summary>
+    /// <param name="path">The path</param>
+    /// <returns></returns>
+    [PublicAPI]
+    public WireMockContainerBuilder WithMappings(string path)
+    {
+        Guard.NotNullOrEmpty(path);
+
+        var isWindows = _isWindowsAsLazy.Value.GetAwaiter().GetResult();
+
+        return WithReadStaticMappings().WithBindMount(path, _info[isWindows].MappingsPath);
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="WireMockContainerBuilder" /> class.
+    /// </summary>
+    /// <param name="dockerResourceConfiguration">The Docker resource configuration.</param>
+    private WireMockContainerBuilder(WireMockConfiguration dockerResourceConfiguration) : base(dockerResourceConfiguration)
+    {
+        DockerResourceConfiguration = dockerResourceConfiguration;
+    }
+
+    /// <inheritdoc />
+    protected override WireMockConfiguration DockerResourceConfiguration { get; }
+
+    /// <inheritdoc />
+    public override WireMockContainer Build()
+    {
+        Validate();
+
+        return new WireMockContainer(DockerResourceConfiguration, TestcontainersSettings.Logger);
+    }
+
+    /// <inheritdoc />
+    protected override WireMockContainerBuilder Init()
+    {
+        var builder = base.Init();
+
+        // In case no image has been set, set the image using internal logic.
+        if (builder.DockerResourceConfiguration.Image == null)
+        {
+            builder = builder.WithImage();
+        }
+
+        var isWindows = _isWindowsAsLazy.Value.GetAwaiter().GetResult();
+        var waitForContainerOS = isWindows ? Wait.ForWindowsContainer() : Wait.ForUnixContainer();
+        return builder
+            .WithPortBinding(WireMockContainer.ContainerPort, true)
+            .WithCommand($"--WireMockLogger {DefaultLogger}")
+            .WithWaitStrategy(waitForContainerOS.UntilMessageIsLogged("By Stef Heyenrath"));
+    }
+
+    /// <inheritdoc />
+    protected override WireMockContainerBuilder Clone(IContainerConfiguration resourceConfiguration)
+    {
+        return Merge(DockerResourceConfiguration, new WireMockConfiguration(resourceConfiguration));
+    }
+
+    /// <inheritdoc />
+    protected override WireMockContainerBuilder Clone(IResourceConfiguration<CreateContainerParameters> resourceConfiguration)
+    {
+        return Merge(DockerResourceConfiguration, new WireMockConfiguration(resourceConfiguration));
+    }
+
+    /// <inheritdoc />
+    protected override WireMockContainerBuilder Merge(WireMockConfiguration oldValue, WireMockConfiguration newValue)
+    {
+        return new WireMockContainerBuilder(new WireMockConfiguration(oldValue, newValue));
+    }
+}
--- a/src/WireMock.Net/.filenesting.json
+++ b/src/WireMock.Net/.filenesting.json
@@ -0,0 +1,17 @@
+{
+    "help": "https://go.microsoft.com/fwlink/?linkid=866610",
+    "root": true,
+
+    "dependentFileProviders": {
+        "add": {
+            "addedExtension": {},
+            "pathSegment": {
+                "add": {
+                    ".*": [
+                        ".cs"
+                    ]
+                }
+            }
+        }
+    }
+}
--- a/src/WireMock.Net/Extensions/DictionaryExtensions.cs
+++ b/src/WireMock.Net/Extensions/DictionaryExtensions.cs
@@ -0,0 +1,29 @@
+using System.Collections;
+using System.Diagnostics.CodeAnalysis;
+using Stef.Validation;
+
+namespace WireMock.Extensions;
+
+internal static class DictionaryExtensions
+{
+    public static bool TryGetStringValue(this IDictionary dictionary, string key, [NotNullWhen(true)] out string? value)
+    {
+        Guard.NotNull(dictionary);
+        
+        if (dictionary[key] is string valueIsString)
+        {
+            value = valueIsString;
+            return true;
+        }
+
+        var valueToString = dictionary[key]?.ToString();
+        if (valueToString != null)
+        {
+            value = valueToString;
+            return true;
+        }
+
+        value = default;
+        return false;
+    }
+}
--- a/src/WireMock.Net/Http/HttpRequestMessageHelper.cs
+++ b/src/WireMock.Net/Http/HttpRequestMessageHelper.cs
@@ -5,12 +5,18 @@ using System.Net.Http;
 using System.Net.Http.Headers;
 using Newtonsoft.Json;
 using Stef.Validation;
+using WireMock.Constants;
 using WireMock.Types;

 namespace WireMock.Http;

 internal static class HttpRequestMessageHelper
 {
+    private static readonly IDictionary<string, bool> ContentLengthHeaderAllowed = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase)
+    {
+        { HttpRequestMethod.HEAD, true }
+    };
+
    internal static HttpRequestMessage Create(IRequestMessage requestMessage, string url)
    {
        Guard.NotNull(requestMessage);
@@ -50,7 +56,19 @@ internal static class HttpRequestMessageHelper
            return httpRequestMessage;
        }

-        var excludeHeaders = new List<string> { HttpKnownHeaderNames.Host, HttpKnownHeaderNames.ContentLength };
+        var excludeHeaders = new List<string> { HttpKnownHeaderNames.Host };
+
+        var contentLengthHeaderAllowed = ContentLengthHeaderAllowed.TryGetValue(requestMessage.Method, out var allowed) && allowed;
+        if (contentLengthHeaderAllowed)
+        {
+            // Set Content to empty ByteArray to be able to set the Content-Length on the content in case of a HEAD method.
+            httpRequestMessage.Content ??= new ByteArrayContent(EmptyArray<byte>.Value);
+        }
+        else
+        {
+            excludeHeaders.Add(HttpKnownHeaderNames.ContentLength);
+        }
+
        if (contentType != null)
        {
            // Content-Type should be set on the content
--- a/src/WireMock.Net/Owin/WireMockMiddleware.cs
+++ b/src/WireMock.Net/Owin/WireMockMiddleware.cs
@@ -60,7 +60,7 @@ namespace WireMock.Owin
        public Task Invoke(IContext ctx)
 #endif
        {
-            if (_options.HandleRequestsSynchronously.GetValueOrDefault(true))
+            if (_options.HandleRequestsSynchronously.GetValueOrDefault(false))
            {
                lock (_lock)
                {
@@ -216,7 +216,12 @@ namespace WireMock.Owin
                {
                    try
                    {
-                        await webhookSender.SendAsync(httpClientForWebhook, mapping, webhookRequest, request, response).ConfigureAwait(false);
+                        var result = await webhookSender.SendAsync(httpClientForWebhook, mapping, webhookRequest, request, response).ConfigureAwait(false);
+                        if (!result.IsSuccessStatusCode)
+                        {
+                            var content = await result.Content.ReadAsStringAsync().ConfigureAwait(false);
+                            _options.Logger.Warn($"Sending message to Webhook [{webHookIndex}] from Mapping '{mapping.Guid}' failed. HttpStatusCode: {result.StatusCode} Content: {content}");
+                        }
                    }
                    catch (Exception ex)
                    {
--- a/src/WireMock.Net/RequestMessage.cs
+++ b/src/WireMock.Net/RequestMessage.cs
@@ -180,12 +180,7 @@ public class RequestMessage : IRequestMessage
 #endif
    }

-    /// <summary>
-    /// Get a query parameter.
-    /// </summary>
-    /// <param name="key">The key.</param>
-    /// <param name="ignoreCase">Defines if the key should be matched using case-ignore.</param>
-    /// <returns>The query parameter.</returns>
+    /// <inheritdoc />
    public WireMockList<string>? GetParameter(string key, bool ignoreCase = false)
    {
        if (Query == null)
--- a/src/WireMock.Net/Serialization/MappingConverter.cs
+++ b/src/WireMock.Net/Serialization/MappingConverter.cs
@@ -107,11 +107,28 @@ internal class MappingConverter

        if (bodyMatcher is { Matchers: { } })
        {
-            var wildcardMatcher = bodyMatcher.Matchers.OfType<WildcardMatcher>().FirstOrDefault();
-            if (wildcardMatcher is { } && wildcardMatcher.GetPatterns().Any())
+            if (bodyMatcher.Matchers.OfType<WildcardMatcher>().FirstOrDefault() is { } wildcardMatcher && wildcardMatcher.GetPatterns().Any())
            {
                sb.AppendLine($"        .WithBody({GetString(wildcardMatcher)})");
            }
+            else if (bodyMatcher.Matchers.OfType<JsonPartialMatcher>().FirstOrDefault() is { Value: { } } jsonPartialMatcher)
+            {
+                sb.AppendLine(@$"        .WithBody(new JsonPartialMatcher(
+                                            value: {ToCSharpStringLiteral(jsonPartialMatcher.Value.ToString())},
+                                            ignoreCase: {ToCSharpBooleanLiteral(jsonPartialMatcher.IgnoreCase)},
+                                            throwException: {ToCSharpBooleanLiteral(jsonPartialMatcher.ThrowException)},
+                                            regex: {ToCSharpBooleanLiteral(jsonPartialMatcher.Regex)}
+                                         ))");
+            }
+            else if (bodyMatcher.Matchers.OfType<JsonPartialWildcardMatcher>().FirstOrDefault() is { Value: { } } jsonPartialWildcardMatcher)
+            {
+                sb.AppendLine(@$"        .WithBody(new JsonPartialWildcardMatcher(
+                                            value: {ToCSharpStringLiteral(jsonPartialWildcardMatcher.Value.ToString())},
+                                            ignoreCase: {ToCSharpBooleanLiteral(jsonPartialWildcardMatcher.IgnoreCase)},
+                                            throwException: {ToCSharpBooleanLiteral(jsonPartialWildcardMatcher.ThrowException)},
+                                            regex: {ToCSharpBooleanLiteral(jsonPartialWildcardMatcher.Regex)}
+                                         ))");
+            }
        }

        sb.AppendLine(@"    )");
--- a/src/WireMock.Net/Settings/SimpleCommandLineParser.cs
+++ b/src/WireMock.Net/Settings/SimpleCommandLineParser.cs
@@ -1,17 +1,21 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using WireMock.Extensions;

 namespace WireMock.Settings;

 // Based on http://blog.gauffin.org/2014/12/simple-command-line-parser/
-internal class SimpleCommandLineParser
+internal class SimpleSettingsParser
 {
    private const string Sigil = "--";
+    private const string Prefix = $"{nameof(WireMockServerSettings)}__";
+    private static readonly int PrefixLength = Prefix.Length;

    private IDictionary<string, string[]> Arguments { get; } = new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase);

-    public void Parse(string[] arguments)
+    public void Parse(string[] arguments, IDictionary? environment = null)
    {
        string currentName = string.Empty;

@@ -44,6 +48,18 @@ internal class SimpleCommandLineParser
        {
            Arguments[currentName] = values.ToArray();
        }
+
+        // Now also parse environment
+        if (environment != null)
+        {
+            foreach (string key in environment.Keys)
+            {
+                if (key.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase) && environment.TryGetStringValue(key, out var value))
+                {
+                    Arguments[key.Substring(PrefixLength)] = value.Split(' ').ToArray();
+                }
+            }
+        }
    }

    public bool Contains(string name)
@@ -85,7 +101,16 @@ internal class SimpleCommandLineParser
        return Contains(name);
    }

-    public int? GetIntValue(string name, int? defaultValue = null)
+    public int? GetIntValue(string name)
+    {
+        return GetValue<int?>(name, values =>
+        {
+            var value = values.FirstOrDefault();
+            return !string.IsNullOrEmpty(value) ? int.Parse(value) : null;
+        }, null);
+    }
+
+    public int GetIntValue(string name, int defaultValue)
    {
        return GetValue(name, values =>
        {
--- a/src/WireMock.Net/Settings/WireMockServerSettings.cs
+++ b/src/WireMock.Net/Settings/WireMockServerSettings.cs
@@ -22,6 +22,8 @@ namespace WireMock.Settings;
 /// </summary>
 public class WireMockServerSettings
 {
+    internal const int DefaultStartTimeout = 10000;
+
    /// <summary>
    /// Gets or sets the http port.
    /// </summary>
@@ -81,7 +83,7 @@ public class WireMockServerSettings
    /// StartTimeout
    /// </summary>
    [PublicAPI]
-    public int StartTimeout { get; set; } = 10000;
+    public int StartTimeout { get; set; } = DefaultStartTimeout;

    /// <summary>
    /// Allow Partial Mapping (default set to false).
--- a/src/WireMock.Net/Settings/WireMockServerSettingsParser.cs
+++ b/src/WireMock.Net/Settings/WireMockServerSettingsParser.cs
@@ -1,3 +1,4 @@
+using System.Collections;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Linq;
@@ -18,16 +19,16 @@ public static class WireMockServerSettingsParser
    /// Parse commandline arguments into WireMockServerSettings.
    /// </summary>
    /// <param name="args">The commandline arguments</param>
+    /// <param name="environment">The environment settings (optional)</param>
    /// <param name="logger">The logger (optional, can be null)</param>
    /// <param name="settings">The parsed settings</param>
    [PublicAPI]
-    public static bool TryParseArguments(string[] args, [NotNullWhen(true)] out WireMockServerSettings? settings,
-        IWireMockLogger? logger = null)
+    public static bool TryParseArguments(string[] args, IDictionary? environment, [NotNullWhen(true)] out WireMockServerSettings? settings, IWireMockLogger? logger = null)
    {
        Guard.HasNoNulls(args);

-        var parser = new SimpleCommandLineParser();
-        parser.Parse(args);
+        var parser = new SimpleSettingsParser();
+        parser.Parse(args, environment);

        if (parser.GetBoolSwitchValue("help"))
        {
@@ -55,6 +56,7 @@ public static class WireMockServerSettingsParser
            RequestLogExpirationDuration = parser.GetIntValue("RequestLogExpirationDuration"),
            SaveUnmatchedRequests = parser.GetBoolValue(nameof(WireMockServerSettings.SaveUnmatchedRequests)),
            StartAdminInterface = parser.GetBoolValue("StartAdminInterface", true),
+            StartTimeout = parser.GetIntValue(nameof(WireMockServerSettings.StartTimeout), WireMockServerSettings.DefaultStartTimeout),
            ThrowExceptionWhenMatcherFails = parser.GetBoolValue("ThrowExceptionWhenMatcherFails"),
            UseRegexExtended = parser.GetBoolValue(nameof(WireMockServerSettings.UseRegexExtended), true),
            WatchStaticMappings = parser.GetBoolValue("WatchStaticMappings"),
@@ -79,8 +81,7 @@ public static class WireMockServerSettingsParser
        return true;
    }

-    private static void ParseLoggerSettings(WireMockServerSettings settings, IWireMockLogger? logger,
-        SimpleCommandLineParser parser)
+    private static void ParseLoggerSettings(WireMockServerSettings settings, IWireMockLogger? logger, SimpleSettingsParser parser)
    {
        var loggerType = parser.GetStringValue("WireMockLogger");
        switch (loggerType)
@@ -103,7 +104,7 @@ public static class WireMockServerSettingsParser
        }
    }

-    private static void ParseProxyAndRecordSettings(WireMockServerSettings settings, SimpleCommandLineParser parser)
+    private static void ParseProxyAndRecordSettings(WireMockServerSettings settings, SimpleSettingsParser parser)
    {
        var proxyUrl = parser.GetStringValue("ProxyURL") ?? parser.GetStringValue("ProxyUrl");
        if (!string.IsNullOrEmpty(proxyUrl))
@@ -135,7 +136,7 @@ public static class WireMockServerSettingsParser
        }
    }

-    private static void ParsePortSettings(WireMockServerSettings settings, SimpleCommandLineParser parser)
+    private static void ParsePortSettings(WireMockServerSettings settings, SimpleSettingsParser parser)
    {
        if (parser.Contains(nameof(WireMockServerSettings.Port)))
        {
@@ -147,7 +148,7 @@ public static class WireMockServerSettingsParser
        }
    }

-    private static void ParseCertificateSettings(WireMockServerSettings settings, SimpleCommandLineParser parser)
+    private static void ParseCertificateSettings(WireMockServerSettings settings, SimpleSettingsParser parser)
    {
        var certificateSettings = new WireMockCertificateSettings
        {
@@ -163,7 +164,7 @@ public static class WireMockServerSettingsParser
        }
    }

-    private static void ParseWebProxyAddressSettings(ProxyAndRecordSettings settings, SimpleCommandLineParser parser)
+    private static void ParseWebProxyAddressSettings(ProxyAndRecordSettings settings, SimpleSettingsParser parser)
    {
        string? proxyAddress = parser.GetStringValue("WebProxyAddress");
        if (!string.IsNullOrEmpty(proxyAddress))
@@ -177,7 +178,7 @@ public static class WireMockServerSettingsParser
        }
    }

-    private static void ParseProxyUrlReplaceSettings(ProxyAndRecordSettings settings, SimpleCommandLineParser parser)
+    private static void ParseProxyUrlReplaceSettings(ProxyAndRecordSettings settings, SimpleSettingsParser parser)
    {
        var proxyUrlReplaceOldValue = parser.GetStringValue("ProxyUrlReplaceOldValue");
        var proxyUrlReplaceNewValue = parser.GetStringValue("ProxyUrlReplaceNewValue");
--- a/src/WireMock.Net/Util/CSharpFormatter.cs
+++ b/src/WireMock.Net/Util/CSharpFormatter.cs
@@ -92,6 +92,7 @@ internal static class CSharpFormatter
        "while"
    });
    #endregion
+
    private const string Null = "null";

    public static object ConvertToAnonymousObjectDefinition(object jsonBody)
@@ -104,7 +105,7 @@ internal static class CSharpFormatter
        return ConvertJsonToAnonymousObjectDefinition(deserializedBody, 2);
    }

-    private static string ConvertJsonToAnonymousObjectDefinition(JToken token, int ind = 0)
+    public static string ConvertJsonToAnonymousObjectDefinition(JToken token, int ind = 0)
    {
        return token switch
        {
@@ -127,19 +128,29 @@ internal static class CSharpFormatter
            _ => $"UNHANDLED_CASE: {token}"
        };
    }
-    
+
+    public static string ToCSharpBooleanLiteral(bool value) => value ? "true" : "false";
+
    public static string ToCSharpStringLiteral(string? value)
    {
-        var escapedValue = value?.Replace("\"", "\\\"") ?? string.Empty;
-        if (escapedValue.Contains("\n"))
+        if (string.IsNullOrEmpty(value))
        {
-            return $"@\"{escapedValue}\"";
+            return "\"\"";
        }

-        return $"\"{escapedValue}\"";
+        if (value.Contains('\n'))
+        {
+            var escapedValue = value?.Replace("\"", "\"\"") ?? string.Empty;
+            return $"@\"{escapedValue}\"";
+        }
+        else
+        {
+            var escapedValue = value?.Replace("\"", "\\\"") ?? string.Empty;
+            return $"\"{escapedValue}\"";
+        }
    }

-    private static string FormatPropertyName(string propertyName)
+    public static string FormatPropertyName(string propertyName)
    {
        return CSharpReservedKeywords.Contains(propertyName) ? "@" + propertyName : propertyName;
    }
--- a/test/WireMock.Net.Tests/Extensions/DictionaryExtensionsTests.cs
+++ b/test/WireMock.Net.Tests/Extensions/DictionaryExtensionsTests.cs
@@ -0,0 +1,51 @@
+using System.Collections;
+using FluentAssertions;
+using WireMock.Extensions;
+using Xunit;
+
+namespace WireMock.Net.Tests.Extensions;
+
+public class DictionaryExtensionsTests
+{
+    [Fact]
+    public void TryGetStringValue_WhenKeyExistsAndValueIsString_ReturnsTrueAndStringValue()
+    {
+        // Arrange
+        var dictionary = new Hashtable { { "key", "value" } };
+
+        // Act
+        var result = dictionary.TryGetStringValue("key", out var value);
+
+        // Assert
+        result.Should().BeTrue();
+        value.Should().Be("value");
+    }
+
+    [Fact]
+    public void TryGetStringValue_WhenKeyExistsAndValueIsNotString_ReturnsTrueAndStringValue()
+    {
+        // Arrange
+        var dictionary = new Hashtable { { "key", 123 } };
+
+        // Act
+        var result = dictionary.TryGetStringValue("key", out var value);
+
+        // Assert
+        result.Should().BeTrue();
+        value.Should().Be("123");
+    }
+
+    [Fact]
+    public void TryGetStringValue_WhenKeyDoesNotExist_ReturnsFalseAndNull()
+    {
+        // Arrange
+        var dictionary = new Hashtable { { "otherKey", "value" } };
+
+        // Act
+        var result = dictionary.TryGetStringValue("key", out var value);
+
+        // Assert
+        result.Should().BeFalse();
+        value.Should().BeNull();
+    }
+}
--- a/test/WireMock.Net.Tests/FluentAssertions/WireMockAssertionsTests.cs
+++ b/test/WireMock.Net.Tests/FluentAssertions/WireMockAssertionsTests.cs
@@ -210,6 +210,36 @@ public class WireMockAssertionsTests : IDisposable
            .Be($"{string.Join(NewLine, missingValue1Message, missingValue2Message)}{NewLine}");
    }

+    [Fact]
+    public async Task HaveReceivedACall_WithHeader_ShouldCheckAllRequests()
+    {
+        // Arrange
+        using var server = WireMockServer.Start();
+        using var client = server.CreateClient();
+
+        // Act 1
+        await client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "/")
+        {
+            Headers =
+            {
+                Authorization = new AuthenticationHeaderValue("Bearer", "invalidToken")
+            }
+        });
+
+        // Act 2
+        await client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "/")
+        {
+            Headers =
+            {
+                Authorization = new AuthenticationHeaderValue("Bearer", "validToken")
+            }
+        });
+
+        // Assert
+        server.Should().HaveReceivedACall().WithHeader("Authorization", "Bearer invalidToken");
+        server.Should().HaveReceivedACall().WithHeader("Authorization", "Bearer validToken");
+    }
+
    [Fact]
    public async Task HaveReceivedACall_AtUrl_WhenACallWasMadeToUrl_Should_BeOK()
    {
--- a/test/WireMock.Net.Tests/Http/HttpRequestMessageHelperTests.cs
+++ b/test/WireMock.Net.Tests/Http/HttpRequestMessageHelperTests.cs
@@ -1,7 +1,9 @@
 using NFluent;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using FluentAssertions;
 using WireMock.Http;
 using WireMock.Models;
 using WireMock.Types;
@@ -160,4 +162,29 @@ public class HttpRequestMessageHelperTests
        // Assert
        Check.That(message.Content.Headers.GetValues("Content-Type")).ContainsExactly("application/xml; charset=Ascii");
    }
+
+    [Theory]
+    [InlineData("HEAD", true)]
+    [InlineData("GET", false)]
+    [InlineData("PUT", false)]
+    [InlineData("POST", false)]
+    [InlineData("DELETE", false)]
+    [InlineData("TRACE", false)]
+    [InlineData("OPTIONS", false)]
+    [InlineData("CONNECT", false)]
+    [InlineData("PATCH", false)]
+    public void HttpRequestMessageHelper_Create_ContentLengthAllowedForMethod(string method, bool resultShouldBe)
+    {
+        // Arrange
+        var key = "Content-Length";
+        var value = 1234;
+        var headers = new Dictionary<string, string[]> { { key, new[] { "1234" } } };
+        var request = new RequestMessage(new UrlDetails("http://localhost/foo"), method, ClientIp, null, headers);
+
+        // Act
+        var message = HttpRequestMessageHelper.Create(request, "http://url");
+
+        // Assert
+        message.Content?.Headers.ContentLength.Should().Be(resultShouldBe ? value : null);
+    }
 }
--- a/test/WireMock.Net.Tests/MappingBuilderTests.GetMappings.verified.txt
+++ b/test/WireMock.Net.Tests/MappingBuilderTests.GetMappings.verified.txt
@@ -14,6 +14,17 @@
      },
      Methods: [
        GET
+      ],
+      Params: [
+        {
+          Name: test,
+          Matchers: [
+            {
+              Name: LinqMatcher,
+              Pattern: it.Length < 10
+            }
+          ]
+        }
      ]
    },
    Response: {
--- a/test/WireMock.Net.Tests/MappingBuilderTests.ToJson.verified.txt
+++ b/test/WireMock.Net.Tests/MappingBuilderTests.ToJson.verified.txt
@@ -14,6 +14,17 @@
      },
      Methods: [
        GET
+      ],
+      Params: [
+        {
+          Name: test,
+          Matchers: [
+            {
+              Name: LinqMatcher,
+              Pattern: it.Length < 10
+            }
+          ]
+        }
      ]
    },
    Response: {
--- a/test/WireMock.Net.Tests/MappingBuilderTests.cs
+++ b/test/WireMock.Net.Tests/MappingBuilderTests.cs
@@ -6,6 +6,7 @@ using VerifyTests;
 using VerifyXunit;
 using WireMock.Handlers;
 using WireMock.Logging;
+using WireMock.Matchers;
 using WireMock.Net.Tests.VerifyExtensions;
 using WireMock.Owin;
 using WireMock.RequestBuilders;
@@ -65,6 +66,7 @@ public class MappingBuilderTests

        _sut.Given(Request.Create()
            .WithPath("/foo")
+            .WithParam("test", new LinqMatcher("it.Length < 10"))
            .UsingGet()
        )
        .WithGuid(MappingGuid)
--- a/test/WireMock.Net.Tests/Pact/PactTests.cs
+++ b/test/WireMock.Net.Tests/Pact/PactTests.cs
@@ -42,7 +42,14 @@ public class PactTests
                    })
            );

-        server.SavePact(Path.Combine("../../../", "Pact", "files"), "pact-get.json");
+        var folder = Path.Combine("../../../", "Pact", "files");
+        var file = "pact-get.json";
+
+        // Act
+        server.SavePact(folder, file);
+
+        // Assert
+        File.ReadAllBytes(Path.Combine(folder, file)).Length.Should().BeGreaterThan(1);
    }

    [Fact]
@@ -201,6 +208,13 @@ public class PactTests
                    })
            );

-        server.SavePact(Path.Combine("../../../", "Pact", "files"), "pact-multiple.json");
+        var folder = Path.Combine("../../../", "Pact", "files");
+        var file = "pact-multiple.json";
+
+        // Act
+        server.SavePact(folder, file);
+
+        // Assert
+        File.ReadAllBytes(Path.Combine(folder, file)).Length.Should().BeGreaterThan(1);
    }
 }
--- a/test/WireMock.Net.Tests/Settings/SimpleCommandLineParserTests.cs
+++ b/test/WireMock.Net.Tests/Settings/SimpleCommandLineParserTests.cs
@@ -1,102 +0,0 @@
-using NFluent;
-using WireMock.Settings;
-using Xunit;
-
-namespace WireMock.Net.Tests.Settings;
-
-public class SimpleCommandLineParserTests
-{
-    private readonly SimpleCommandLineParser _parser;
-
-    public SimpleCommandLineParserTests()
-    {
-        _parser = new SimpleCommandLineParser();
-    }
-
-    [Fact]
-    public void SimpleCommandLineParser_Parse_Arguments()
-    {
-        // Assign
-        _parser.Parse(new[] { "--test1", "one", "--test2", "two", "--test3", "three" });
-
-        // Act
-        string? value1 = _parser.GetStringValue("test1");
-        string? value2 = _parser.GetStringValue("test2");
-        string? value3 = _parser.GetStringValue("test3");
-
-        // Assert
-        Check.That(value1).IsEqualTo("one");
-        Check.That(value2).IsEqualTo("two");
-        Check.That(value3).IsEqualTo("three");
-    }
-
-    [Fact]
-    public void SimpleCommandLineParser_Parse_ArgumentsAsCombinedKeyAndValue()
-    {
-        // Assign
-        _parser.Parse(new[] { "--test1 one", "--test2 two", "--test3 three" });
-
-        // Act
-        string? value1 = _parser.GetStringValue("test1");
-        string? value2 = _parser.GetStringValue("test2");
-        string? value3 = _parser.GetStringValue("test3");
-
-        // Assert
-        Check.That(value1).IsEqualTo("one");
-        Check.That(value2).IsEqualTo("two");
-        Check.That(value3).IsEqualTo("three");
-    }
-
-    [Fact]
-    public void SimpleCommandLineParser_Parse_ArgumentsMixed()
-    {
-        // Assign
-        _parser.Parse(new[] { "--test1 one", "--test2", "two", "--test3 three" });
-
-        // Act
-        string? value1 = _parser.GetStringValue("test1");
-        string? value2 = _parser.GetStringValue("test2");
-        string? value3 = _parser.GetStringValue("test3");
-
-        // Assert
-        Check.That(value1).IsEqualTo("one");
-        Check.That(value2).IsEqualTo("two");
-        Check.That(value3).IsEqualTo("three");
-    }
-
-    [Fact]
-    public void SimpleCommandLineParser_Parse_GetBoolValue()
-    {
-        // Assign
-        _parser.Parse(new[] { "'--test1", "false'", "--test2 true" });
-
-        // Act
-        bool value1 = _parser.GetBoolValue("test1");
-        bool value2 = _parser.GetBoolValue("test2");
-        bool value3 = _parser.GetBoolValue("test3", true);
-
-        // Assert
-        Check.That(value1).IsEqualTo(false);
-        Check.That(value2).IsEqualTo(true);
-        Check.That(value3).IsEqualTo(true);
-    }
-
-    [Fact]
-    public void SimpleCommandLineParser_Parse_GetIntValue()
-    {
-        // Assign
-        _parser.Parse(new[] { "--test1", "42", "--test2 55" });
-
-        // Act
-        int? value1 = _parser.GetIntValue("test1");
-        int? value2 = _parser.GetIntValue("test2");
-        int? value3 = _parser.GetIntValue("test3", 100);
-        int? value4 = _parser.GetIntValue("test4");
-
-        // Assert
-        Check.That(value1).IsEqualTo(42);
-        Check.That(value2).IsEqualTo(55);
-        Check.That(value3).IsEqualTo(100);
-        Check.That(value4).IsNull();
-    }
-}
--- a/test/WireMock.Net.Tests/Settings/SimpleSettingsParserTests.cs
+++ b/test/WireMock.Net.Tests/Settings/SimpleSettingsParserTests.cs
@@ -0,0 +1,177 @@
+using System.Collections.Generic;
+using FluentAssertions;
+using NFluent;
+using WireMock.Settings;
+using WireMock.Types;
+using Xunit;
+
+namespace WireMock.Net.Tests.Settings;
+
+public class SimpleSettingsParserTests
+{
+    private readonly SimpleSettingsParser _parser;
+
+    public SimpleSettingsParserTests()
+    {
+        _parser = new SimpleSettingsParser();
+    }
+
+    [Fact]
+    public void SimpleCommandLineParser_Parse_Arguments()
+    {
+        // Assign
+        _parser.Parse(new[] { "--test1", "one", "--test2", "2", "--test3", "3", "--test4", "true", "--test5", "Https" });
+
+        // Act
+        string? stringValue = _parser.GetStringValue("test1");
+        int? intOptional = _parser.GetIntValue("test2");
+        int intWithDefault = _parser.GetIntValue("test3", 42);
+        bool? boolWithDefault = _parser.GetBoolValue("test4");
+        HostingScheme? enumOptional = _parser.GetEnumValue<HostingScheme>("test5");
+        HostingScheme enumWithDefault = _parser.GetEnumValue("test99", HostingScheme.HttpAndHttps);
+
+        // Assert
+        stringValue.Should().Be("one");
+        intOptional.Should().Be(2);
+        intWithDefault.Should().Be(3);
+        boolWithDefault.Should().Be(true);
+        enumOptional.Should().Be(HostingScheme.Https);
+        enumWithDefault.Should().Be(HostingScheme.HttpAndHttps);
+    }
+
+    [Fact]
+    public void SimpleCommandLineParser_Parse_Environment()
+    {
+        // Assign
+        var env = new Dictionary<string, string>
+        {
+            { "WireMockServerSettings__test1", "one" },
+            { "WireMockServerSettings__test2", "two" }
+        };
+        _parser.Parse(new string[0], env);
+
+        // Act
+        string? value1 = _parser.GetStringValue("test1");
+        string? value2 = _parser.GetStringValue("test2");
+
+        // Assert
+        Check.That(value1).IsEqualTo("one");
+        Check.That(value2).IsEqualTo("two");
+    }
+
+    [Fact]
+    public void SimpleCommandLineParser_Parse_ArgumentsAsCombinedKeyAndValue()
+    {
+        // Assign
+        _parser.Parse(new[] { "--test1 one", "--test2 two", "--test3 three" });
+
+        // Act
+        string? value1 = _parser.GetStringValue("test1");
+        string? value2 = _parser.GetStringValue("test2");
+        string? value3 = _parser.GetStringValue("test3");
+
+        // Assert
+        Check.That(value1).IsEqualTo("one");
+        Check.That(value2).IsEqualTo("two");
+        Check.That(value3).IsEqualTo("three");
+    }
+
+    [Fact]
+    public void SimpleCommandLineParser_Parse_ArgumentsMixed()
+    {
+        // Assign
+        _parser.Parse(new[] { "--test1 one", "--test2", "two", "--test3 three" });
+
+        // Act
+        string? value1 = _parser.GetStringValue("test1");
+        string? value2 = _parser.GetStringValue("test2");
+        string? value3 = _parser.GetStringValue("test3");
+
+        // Assert
+        Check.That(value1).IsEqualTo("one");
+        Check.That(value2).IsEqualTo("two");
+        Check.That(value3).IsEqualTo("three");
+    }
+
+    [Fact]
+    public void SimpleCommandLineParser_Parse_GetBoolValue()
+    {
+        // Assign
+        _parser.Parse(new[] { "'--test1", "false'", "--test2 true" });
+
+        // Act
+        bool value1 = _parser.GetBoolValue("test1");
+        bool value2 = _parser.GetBoolValue("test2");
+        bool value3 = _parser.GetBoolValue("test3", true);
+
+        // Assert
+        Check.That(value1).IsEqualTo(false);
+        Check.That(value2).IsEqualTo(true);
+        Check.That(value3).IsEqualTo(true);
+    }
+
+    [Fact]
+    public void SimpleCommandLineParser_Parse_Environment_GetBoolValue()
+    {
+        // Assign
+        var env = new Dictionary<string, string>
+        {
+            { "WireMockServerSettings__test1", "false" },
+            { "WireMockServerSettings__test2", "true" }
+        };
+        _parser.Parse(new string[0], env);
+
+        // Act
+        bool value1 = _parser.GetBoolValue("test1");
+        bool value2 = _parser.GetBoolValue("test2");
+        bool value3 = _parser.GetBoolValue("test3", true);
+
+        // Assert
+        Check.That(value1).IsEqualTo(false);
+        Check.That(value2).IsEqualTo(true);
+        Check.That(value3).IsEqualTo(true);
+    }
+
+    [Fact]
+    public void SimpleCommandLineParser_Parse_GetIntValue()
+    {
+        // Assign
+        _parser.Parse(new[] { "--test1", "42", "--test2 55" });
+
+        // Act
+        int? value1 = _parser.GetIntValue("test1");
+        int? value2 = _parser.GetIntValue("test2");
+        int? value3 = _parser.GetIntValue("test3", 100);
+        int? value4 = _parser.GetIntValue("test4");
+
+        // Assert
+        Check.That(value1).IsEqualTo(42);
+        Check.That(value2).IsEqualTo(55);
+        Check.That(value3).IsEqualTo(100);
+        Check.That(value4).IsNull();
+    }
+
+    [Fact]
+    public void SimpleCommandLineParser_Parse_Environment_GetIntValue()
+    {
+        // Assign
+        var env = new Dictionary<string, string>
+        {
+            { "WireMockServerSettings__test1", "42" },
+            { "WireMockServerSETTINGS__TEST2", "55" }
+        };
+        _parser.Parse(new string[0], env);
+
+        // Act
+        int? value1 = _parser.GetIntValue("test1");
+        int? value2 = _parser.GetIntValue("test2");
+        int? value3 = _parser.GetIntValue("test3", 100);
+        int? value4 = _parser.GetIntValue("test4");
+
+        // Assert
+        Check.That(value1).IsEqualTo(42);
+        Check.That(value2).IsEqualTo(55);
+        Check.That(value3).IsEqualTo(100);
+        Check.That(value4).IsNull();
+    }
+}
--- a/test/WireMock.Net.Tests/Util/BytesEncodingUtilsTests.cs
+++ b/test/WireMock.Net.Tests/Util/BytesEncodingUtilsTests.cs
@@ -10,17 +10,17 @@ public class BytesEncodingUtilsTests
    [Fact]
    public void TryGetEncoding_UTF32()
    {
-        var result = BytesEncodingUtils.TryGetEncoding(new byte[] { 0xff, 0xfe, 0x00, 0x00 }, out Encoding encoding);
+        var result = BytesEncodingUtils.TryGetEncoding(new byte[] { 0xff, 0xfe, 0x00, 0x00 }, out var encoding);

        // Assert
        result.Should().BeTrue();
-        encoding.CodePage.Should().Be(Encoding.UTF32.CodePage);
+        encoding?.CodePage.Should().Be(Encoding.UTF32.CodePage);
    }

    [Fact]
    public void TryGetEncoding_Invalid()
    {
-        var result = BytesEncodingUtils.TryGetEncoding(new byte[] { 0xff }, out Encoding encoding);
+        var result = BytesEncodingUtils.TryGetEncoding(new byte[] { 0xff }, out var encoding);

        // Assert
        result.Should().BeFalse();
--- a/test/WireMock.Net.Tests/Util/CSharpFormatterTests.cs
+++ b/test/WireMock.Net.Tests/Util/CSharpFormatterTests.cs
@@ -0,0 +1,105 @@
+using FluentAssertions;
+using Newtonsoft.Json.Linq;
+using WireMock.Util;
+using Xunit;
+
+namespace WireMock.Net.Tests.Util;
+
+public class CSharpFormatterTests
+{
+    [Fact]
+    public void ConvertToAnonymousObjectDefinition_ShouldReturn_ValidValue_WhenJsonBodyIsValidJsonString()
+    {
+        // Arrange
+        var jsonBody = new { Key1 = "value1", Key2 = 42, F = 1.2 };
+        var expectedOutput = "new\r\n        {\r\n            Key1 = \"value1\",\r\n            Key2 = 42,\r\n            F = 1.2\r\n        }";
+
+        // Act
+        var result = CSharpFormatter.ConvertToAnonymousObjectDefinition(jsonBody);
+
+        // Assert
+        result.Should().Be(expectedOutput);
+    }
+
+    [Fact]
+    public void ToCSharpStringLiteral_ShouldReturn_ValidValue_WhenStringIsNotNull()
+    {
+        // Arrange
+        var inputString = "test string";
+        var expectedOutput = "\"test string\"";
+
+        // Act
+        var result = CSharpFormatter.ToCSharpStringLiteral(inputString);
+
+        // Assert
+        result.Should().Be(expectedOutput);
+    }
+
+    [Fact]
+    public void ToCSharpStringLiteral_ShouldReturn_ValidValue_WhenStringContainsNewLineCharacters()
+    {
+        // Arrange
+        var inputString = "line1\nline2\nline3";
+        var expectedOutput = "@\"line1\nline2\nline3\"";
+
+        // Action
+        var result = CSharpFormatter.ToCSharpStringLiteral(inputString);
+
+        // Assert
+        result.Should().Be(expectedOutput);
+    }
+
+    [Fact]
+    public void FormatPropertyName_ShouldReturn_ValidPropertyName_WhenPropertyNameIsNotReserved()
+    {
+        // Arrange
+        var propertyName = "propertyname";
+        var expectedOutput = "propertyname";
+
+        // Action
+        var result = CSharpFormatter.FormatPropertyName(propertyName);
+
+        // Assert
+        result.Should().Be(expectedOutput);
+    }
+
+    [Fact]
+    public void FormatPropertyName_ShouldReturn_ValidPropertyName_WhenPropertyNameIsReserved()
+    {
+        // Arrange
+        var propertyName = "class";
+        var expectedOutput = "@class";
+
+        // Action
+        var result = CSharpFormatter.FormatPropertyName(propertyName);
+
+        // Assert
+        result.Should().Be(expectedOutput);
+    }
+
+    [Fact]
+    public void ConvertJsonToAnonymousObjectDefinition_ShouldReturn_ValidObject_WhenJsonInputIsValid()
+    {
+        // Arrange
+        var jObject = new JObject
+        (
+            new JProperty("Name", "John Smith"),
+            new JProperty("Age", 25.1f),
+            new JProperty("Gender", "Male"),
+            new JProperty("address", new JObject
+            (
+                new JProperty("Street", "123 Main St"),
+                new JProperty("City", "Anytown"),
+                new JProperty("State", "CA"),
+                new JProperty("Zip", "90001")
+            )
+        ));
+        var expectedOutput = "new\r\n{\r\n    Name = \"John Smith\",\r\n    Age = 25.1,\r\n    Gender = \"Male\",\r\n    address = new\r\n    {\r\n        Street = \"123 Main St\",\r\n        City = \"Anytown\",\r\n        State = \"CA\",\r\n        Zip = \"90001\"\r\n    }\r\n}";
+
+        // Action
+        var result = CSharpFormatter.ConvertJsonToAnonymousObjectDefinition(jObject);
+
+        // Assert
+        result.Should().Be(expectedOutput);
+    }
+}
--- a/test/WireMock.Net.Tests/WireMock.Net.Tests.csproj
+++ b/test/WireMock.Net.Tests/WireMock.Net.Tests.csproj
@@ -25,7 +25,7 @@
    </PropertyGroup>

    <ItemGroup>
-      <Compile Remove="Util\JsonUtilsTests.cs" />
+        <Compile Remove="Util\JsonUtilsTests.cs" />
    </ItemGroup>

    <ItemGroup>
@@ -63,8 +63,6 @@
        </PackageReference>

        <PackageReference Include="Moq" Version="4.17.2" />
-
-        <!--<PackageReference Include="System.Linq.Dynamic.Core" Version="1.3.1" />-->
        <PackageReference Include="System.Threading" Version="4.3.0" />
        <PackageReference Include="RestEase" Version="1.5.7" />
        <PackageReference Include="Newtonsoft.Json" Version="13.0.2" />
@@ -104,10 +102,10 @@

    <ItemGroup>
        <None Update="OpenApiParser\*.json">
-          <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+            <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
        </None>
        <None Update="OpenApiParser\*.yml">
-          <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+            <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
        </None>
        <None Update="responsebody.json">
            <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
--- a/test/WireMock.Net.Tests/WireMockAdminApiTests.IWireMockAdminApi_GetMappingsCode.verified.txt
+++ b/test/WireMock.Net.Tests/WireMockAdminApiTests.IWireMockAdminApi_GetMappingsCode.verified.txt
@@ -70,3 +70,21 @@ text
        })
    );

+server
+    .Given(Request.Create()
+        .UsingMethod("POST")
+        .WithPath("/foo3")
+        .WithBody(new JsonPartialMatcher(
+                                            value: "{ a = 1, b = 2 }",
+                                            ignoreCase: false,
+                                            throwException: false,
+                                            regex: false
+                                         ))
+    )
+    .WithGuid("4126dec8-470b-4eff-93bb-c24f83b8b1fd")
+    .RespondWith(Response.Create()
+        .WithStatusCode(200)
+        .WithBody(@"Line1
+Some ""value"" in Line2")
+    );
+
--- a/test/WireMock.Net.Tests/WireMockAdminApiTests.cs
+++ b/test/WireMock.Net.Tests/WireMockAdminApiTests.cs
@@ -18,6 +18,7 @@ using WireMock.Admin.Settings;
 using WireMock.Client;
 using WireMock.Handlers;
 using WireMock.Logging;
+using WireMock.Matchers;
 using WireMock.Models;
 using WireMock.Net.Tests.VerifyExtensions;
 using WireMock.RequestBuilders;
@@ -719,6 +720,7 @@ public class WireMockAdminApiTests
        var guid1 = Guid.Parse("90356dba-b36c-469a-a17e-669cd84f1f05");
        var guid2 = Guid.Parse("1b731398-4a5b-457f-a6e3-d65e541c428f");
        var guid3 = Guid.Parse("f74fd144-df53-404f-8e35-da22a640bd5f");
+        var guid4 = Guid.Parse("4126DEC8-470B-4EFF-93BB-C24F83B8B1FD");
        var server = WireMockServer.StartWithAdminInterface();

        server
@@ -769,11 +771,25 @@ text
 " })
            );

+        server
+            .Given(
+                Request.Create()
+                    .WithPath("/foo3")
+                    .WithBody(new JsonPartialMatcher(new { a=1, b=2}))
+                    .UsingPost()
+            )
+            .WithGuid(guid4)
+            .RespondWith(
+                Response.Create()
+                    .WithStatusCode(200)
+                    .WithBody("Line1\r\nSome \"value\" in Line2")
+            );
+
        // Act
        var api = RestClient.For<IWireMockAdminApi>(server.Url);

        var mappings = await api.GetMappingsAsync().ConfigureAwait(false);
-        mappings.Should().HaveCount(3);
+        mappings.Should().HaveCount(4);

        var code = await api.GetMappingsCodeAsync().ConfigureAwait(false);

--- a/test/WireMock.Net.Tests/WireMockServer.AdminFiles.cs
+++ b/test/WireMock.Net.Tests/WireMockServer.AdminFiles.cs
@@ -1,215 +1,210 @@
-using Moq;
-using NFluent;
 using System.IO;
-using System.Linq;
 using System.Net;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Text;
 using System.Threading.Tasks;
+using FluentAssertions;
+using Moq;
 using WireMock.Handlers;
 using WireMock.Server;
 using WireMock.Settings;
 using Xunit;

-namespace WireMock.Net.Tests
+namespace WireMock.Net.Tests;
+
+public class WireMockServerAdminFilesTests
 {
-    public class WireMockServerAdminFilesTests
+    private readonly HttpClient _client = new HttpClient();
+
+    [Fact]
+    public async Task WireMockServer_Admin_Files_Post_Ascii()
    {
-        private readonly HttpClient _client = new HttpClient();
+        // Arrange
+        var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+        filesystemHandlerMock.Setup(fs => fs.GetMappingFolder()).Returns("__admin/mappings");
+        filesystemHandlerMock.Setup(fs => fs.FolderExists(It.IsAny<string>())).Returns(true);
+        filesystemHandlerMock.Setup(fs => fs.WriteFile(It.IsAny<string>(), It.IsAny<byte[]>()));

-        [Fact]
-        public async Task WireMockServer_Admin_Files_Post_Ascii()
+        var server = WireMockServer.Start(new WireMockServerSettings
        {
-            // Arrange
-            var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
-            filesystemHandlerMock.Setup(fs => fs.GetMappingFolder()).Returns("__admin/mappings");
-            filesystemHandlerMock.Setup(fs => fs.FolderExists(It.IsAny<string>())).Returns(true);
-            filesystemHandlerMock.Setup(fs => fs.WriteFile(It.IsAny<string>(), It.IsAny<byte[]>()));
+            UseSSL = false,
+            StartAdminInterface = true,
+            FileSystemHandler = filesystemHandlerMock.Object
+        });

-            var server = WireMockServer.Start(new WireMockServerSettings
-            {
-                UseSSL = false,
-                StartAdminInterface = true,
-                FileSystemHandler = filesystemHandlerMock.Object
-            });
+        var multipartFormDataContent = new MultipartFormDataContent();
+        multipartFormDataContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
+        multipartFormDataContent.Add(new StreamContent(new MemoryStream(Encoding.ASCII.GetBytes("Here's a string."))));

-            var multipartFormDataContent = new MultipartFormDataContent();
-            multipartFormDataContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
-            multipartFormDataContent.Add(new StreamContent(new MemoryStream(Encoding.ASCII.GetBytes("Here's a string."))));
+        // Act
+        var httpResponseMessage = await _client.PostAsync("http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt", multipartFormDataContent).ConfigureAwait(false);

-            // Act
-            var httpResponseMessage = await _client.PostAsync("http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt", multipartFormDataContent).ConfigureAwait(false);
+        // Assert
+        httpResponseMessage.StatusCode.Should().Be(HttpStatusCode.OK);

-            // Assert
-            Check.That(httpResponseMessage.StatusCode).Equals(HttpStatusCode.OK);
-            Check.That(server.LogEntries.Count().Equals(1));
+        // Verify
+        filesystemHandlerMock.Verify(fs => fs.GetMappingFolder(), Times.Once);
+        filesystemHandlerMock.Verify(fs => fs.FolderExists(It.IsAny<string>()), Times.Once);
+        filesystemHandlerMock.Verify(fs => fs.WriteFile(It.Is<string>(p => p == "filename.txt"), It.IsAny<byte[]>()), Times.Once);
+        filesystemHandlerMock.VerifyNoOtherCalls();
+    }

-            // Verify
-            filesystemHandlerMock.Verify(fs => fs.GetMappingFolder(), Times.Once);
-            filesystemHandlerMock.Verify(fs => fs.FolderExists(It.IsAny<string>()), Times.Once);
-            filesystemHandlerMock.Verify(fs => fs.WriteFile(It.Is<string>(p => p == "filename.txt"), It.IsAny<byte[]>()), Times.Once);
-            filesystemHandlerMock.VerifyNoOtherCalls();
-        }
+    [Fact]
+    public async Task WireMockServer_Admin_Files_Post_MappingFolderDoesNotExistsButWillBeCreated()
+    {
+        // Arrange
+        var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+        filesystemHandlerMock.Setup(fs => fs.GetMappingFolder()).Returns("x");
+        filesystemHandlerMock.Setup(fs => fs.CreateFolder(It.IsAny<string>()));
+        filesystemHandlerMock.Setup(fs => fs.FolderExists(It.IsAny<string>())).Returns(false);
+        filesystemHandlerMock.Setup(fs => fs.WriteFile(It.IsAny<string>(), It.IsAny<byte[]>()));

-        [Fact]
-        public async Task WireMockServer_Admin_Files_Post_MappingFolderDoesNotExistsButWillBeCreated()
+        var server = WireMockServer.Start(new WireMockServerSettings
        {
-            // Arrange
-            var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
-            filesystemHandlerMock.Setup(fs => fs.GetMappingFolder()).Returns("x");
-            filesystemHandlerMock.Setup(fs => fs.CreateFolder(It.IsAny<string>()));
-            filesystemHandlerMock.Setup(fs => fs.FolderExists(It.IsAny<string>())).Returns(false);
-            filesystemHandlerMock.Setup(fs => fs.WriteFile(It.IsAny<string>(), It.IsAny<byte[]>()));
+            UseSSL = false,
+            StartAdminInterface = true,
+            FileSystemHandler = filesystemHandlerMock.Object
+        });

-            var server = WireMockServer.Start(new WireMockServerSettings
-            {
-                UseSSL = false,
-                StartAdminInterface = true,
-                FileSystemHandler = filesystemHandlerMock.Object
-            });
+        var multipartFormDataContent = new MultipartFormDataContent();
+        multipartFormDataContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
+        multipartFormDataContent.Add(new StreamContent(new MemoryStream(Encoding.ASCII.GetBytes("Here's a string."))));

-            var multipartFormDataContent = new MultipartFormDataContent();
-            multipartFormDataContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
-            multipartFormDataContent.Add(new StreamContent(new MemoryStream(Encoding.ASCII.GetBytes("Here's a string."))));
+        // Act
+        var httpResponseMessage = await _client.PostAsync("http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt", multipartFormDataContent).ConfigureAwait(false);

-            // Act
-            var httpResponseMessage = await _client.PostAsync("http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt", multipartFormDataContent).ConfigureAwait(false);
+        // Assert
+        httpResponseMessage.StatusCode.Should().Be(HttpStatusCode.OK);

-            // Assert
-            Check.That(httpResponseMessage.StatusCode).Equals(HttpStatusCode.OK);
+        // Verify
+        filesystemHandlerMock.Verify(fs => fs.GetMappingFolder(), Times.Once);
+        filesystemHandlerMock.Verify(fs => fs.FolderExists(It.IsAny<string>()), Times.Once);
+        filesystemHandlerMock.Verify(fs => fs.CreateFolder(It.Is<string>(p => p == "x")), Times.Once);
+        filesystemHandlerMock.Verify(fs => fs.WriteFile(It.Is<string>(p => p == "filename.txt"), It.IsAny<byte[]>()), Times.Once);
+        filesystemHandlerMock.VerifyNoOtherCalls();
+    }

-            // Verify
-            filesystemHandlerMock.Verify(fs => fs.GetMappingFolder(), Times.Once);
-            filesystemHandlerMock.Verify(fs => fs.FolderExists(It.IsAny<string>()), Times.Once);
-            filesystemHandlerMock.Verify(fs => fs.CreateFolder(It.Is<string>(p => p == "x")), Times.Once);
-            filesystemHandlerMock.Verify(fs => fs.WriteFile(It.Is<string>(p => p == "filename.txt"), It.IsAny<byte[]>()), Times.Once);
-            filesystemHandlerMock.VerifyNoOtherCalls();
-        }
+    [Fact]
+    public async Task WireMockServer_Admin_Files_GetAscii()
+    {
+        // Arrange
+        var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+        filesystemHandlerMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(true);
+        filesystemHandlerMock.Setup(fs => fs.ReadFile(It.IsAny<string>())).Returns(Encoding.ASCII.GetBytes("Here's a string."));

-        [Fact]
-        public async Task WireMockServer_Admin_Files_GetAscii()
+        var server = WireMockServer.Start(new WireMockServerSettings
        {
-            // Arrange
-            var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
-            filesystemHandlerMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(true);
-            filesystemHandlerMock.Setup(fs => fs.ReadFile(It.IsAny<string>())).Returns(Encoding.ASCII.GetBytes("Here's a string."));
+            UseSSL = false,
+            StartAdminInterface = true,
+            FileSystemHandler = filesystemHandlerMock.Object
+        });

-            var server = WireMockServer.Start(new WireMockServerSettings
-            {
-                UseSSL = false,
-                StartAdminInterface = true,
-                FileSystemHandler = filesystemHandlerMock.Object
-            });
+        var multipartFormDataContent = new MultipartFormDataContent();
+        multipartFormDataContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
+        multipartFormDataContent.Add(new StreamContent(new MemoryStream()));

-            var multipartFormDataContent = new MultipartFormDataContent();
-            multipartFormDataContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
-            multipartFormDataContent.Add(new StreamContent(new MemoryStream()));
+        // Act
+        var httpResponseMessageGet = await _client.GetAsync("http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt").ConfigureAwait(false);

-            // Act
-            var httpResponseMessageGet = await _client.GetAsync("http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt").ConfigureAwait(false);
+        // Assert
+        httpResponseMessageGet.StatusCode.Should().Be(HttpStatusCode.OK);

-            // Assert
-            Check.That(httpResponseMessageGet.StatusCode).Equals(HttpStatusCode.OK);
+        var result = await httpResponseMessageGet.Content.ReadAsStringAsync().ConfigureAwait(false);
+        result.Should().Be("Here's a string.");

-            Check.That(httpResponseMessageGet.Content.ReadAsStringAsync().Result).Equals("Here's a string.");
+        // Verify
+        filesystemHandlerMock.Verify(fs => fs.ReadFile(It.Is<string>(p => p == "filename.txt")), Times.Once);
+        filesystemHandlerMock.Verify(fs => fs.FileExists(It.Is<string>(p => p == "filename.txt")), Times.Once);
+        filesystemHandlerMock.VerifyNoOtherCalls();
+    }

-            Check.That(server.LogEntries.Count().Equals(2));
+    [Fact]
+    public async Task WireMockServer_Admin_Files_GetUTF16()
+    {
+        // Arrange
+        byte[] symbol = Encoding.UTF32.GetBytes(char.ConvertFromUtf32(0x1D161));
+        var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+        filesystemHandlerMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(true);
+        filesystemHandlerMock.Setup(fs => fs.ReadFile(It.IsAny<string>())).Returns(symbol);

-            // Verify
-            filesystemHandlerMock.Verify(fs => fs.ReadFile(It.Is<string>(p => p == "filename.txt")), Times.Once);
-            filesystemHandlerMock.Verify(fs => fs.FileExists(It.Is<string>(p => p == "filename.txt")), Times.Once);
-            filesystemHandlerMock.VerifyNoOtherCalls();
-        }
-
-        [Fact]
-        public async Task WireMockServer_Admin_Files_GetUTF16()
+        var server = WireMockServer.Start(new WireMockServerSettings
        {
-            // Arrange
-            byte[] symbol = Encoding.UTF32.GetBytes(char.ConvertFromUtf32(0x1D161));
-            var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
-            filesystemHandlerMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(true);
-            filesystemHandlerMock.Setup(fs => fs.ReadFile(It.IsAny<string>())).Returns(symbol);
+            UseSSL = false,
+            StartAdminInterface = true,
+            FileSystemHandler = filesystemHandlerMock.Object
+        });

-            var server = WireMockServer.Start(new WireMockServerSettings
-            {
-                UseSSL = false,
-                StartAdminInterface = true,
-                FileSystemHandler = filesystemHandlerMock.Object
-            });
+        var multipartFormDataContent = new MultipartFormDataContent();
+        multipartFormDataContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
+        multipartFormDataContent.Add(new StreamContent(new MemoryStream()));

-            var multipartFormDataContent = new MultipartFormDataContent();
-            multipartFormDataContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
-            multipartFormDataContent.Add(new StreamContent(new MemoryStream()));
+        // Act
+        var httpResponseMessageGet = await _client.GetAsync("http://localhost:" + server.Ports[0] + "/__admin/files/filename.bin").ConfigureAwait(false);

-            // Act
-            var httpResponseMessageGet = await _client.GetAsync("http://localhost:" + server.Ports[0] + "/__admin/files/filename.bin").ConfigureAwait(false);
+        // Assert
+        httpResponseMessageGet.StatusCode.Should().Be(HttpStatusCode.OK);

-            // Assert
-            Check.That(httpResponseMessageGet.StatusCode).Equals(HttpStatusCode.OK);
-            Check.That(httpResponseMessageGet.Content.ReadAsByteArrayAsync().Result).Equals(symbol);
-            Check.That(server.LogEntries.Count().Equals(2));
+        var result = await httpResponseMessageGet.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
+        result.Should().BeEquivalentTo(symbol);

-            // Verify
-            filesystemHandlerMock.Verify(fs => fs.ReadFile(It.Is<string>(p => p == "filename.bin")), Times.Once);
-            filesystemHandlerMock.Verify(fs => fs.FileExists(It.Is<string>(p => p == "filename.bin")), Times.Once);
-            filesystemHandlerMock.VerifyNoOtherCalls();
-        }
+        // Verify
+        filesystemHandlerMock.Verify(fs => fs.ReadFile(It.Is<string>(p => p == "filename.bin")), Times.Once);
+        filesystemHandlerMock.Verify(fs => fs.FileExists(It.Is<string>(p => p == "filename.bin")), Times.Once);
+        filesystemHandlerMock.VerifyNoOtherCalls();
+    }

-        [Fact]
-        public async Task WireMockServer_Admin_Files_Head()
+    [Fact]
+    public async Task WireMockServer_Admin_Files_Head()
+    {
+        // Arrange
+        var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+        filesystemHandlerMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(true);
+
+        var server = WireMockServer.Start(new WireMockServerSettings
        {
-            // Arrange
-            var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
-            filesystemHandlerMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(true);
+            UseSSL = false,
+            StartAdminInterface = true,
+            FileSystemHandler = filesystemHandlerMock.Object
+        });

-            var server = WireMockServer.Start(new WireMockServerSettings
-            {
-                UseSSL = false,
-                StartAdminInterface = true,
-                FileSystemHandler = filesystemHandlerMock.Object
-            });
+        // Act
+        var requestUri = "http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt";
+        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Head, requestUri);
+        var httpResponseMessage = await _client.SendAsync(httpRequestMessage).ConfigureAwait(false);

-            // Act
-            var requestUri = "http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt";
-            var httpRequestMessage = new HttpRequestMessage(HttpMethod.Head, requestUri);
-            var httpResponseMessage = await _client.SendAsync(httpRequestMessage).ConfigureAwait(false);
+        // Assert
+        httpResponseMessage.StatusCode.Should().Be(HttpStatusCode.NoContent);

-            // Assert
-            Check.That(httpResponseMessage.StatusCode).Equals(HttpStatusCode.NoContent);
-            Check.That(server.LogEntries.Count().Equals(1));
+        // Verify
+        filesystemHandlerMock.Verify(fs => fs.FileExists(It.IsAny<string>()), Times.Once);
+        filesystemHandlerMock.VerifyNoOtherCalls();
+    }

-            // Verify
-            filesystemHandlerMock.Verify(fs => fs.FileExists(It.IsAny<string>()), Times.Once);
-            filesystemHandlerMock.VerifyNoOtherCalls();
-        }
+    [Fact]
+    public async Task WireMockServer_Admin_Files_Head_FileDoesNotExistsReturns404()
+    {
+        // Arrange
+        var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+        filesystemHandlerMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(false);

-        [Fact]
-        public async Task WireMockServer_Admin_Files_Head_FileDoesNotExistsReturns404()
+        var server = WireMockServer.Start(new WireMockServerSettings
        {
-            // Arrange
-            var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
-            filesystemHandlerMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(false);
+            UseSSL = false,
+            StartAdminInterface = true,
+            FileSystemHandler = filesystemHandlerMock.Object
+        });

-            var server = WireMockServer.Start(new WireMockServerSettings
-            {
-                UseSSL = false,
-                StartAdminInterface = true,
-                FileSystemHandler = filesystemHandlerMock.Object
-            });
+        // Act
+        var requestUri = "http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt";
+        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Head, requestUri);
+        var httpResponseMessage = await _client.SendAsync(httpRequestMessage).ConfigureAwait(false);

-            // Act
-            var requestUri = "http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt";
-            var httpRequestMessage = new HttpRequestMessage(HttpMethod.Head, requestUri);
-            var httpResponseMessage = await _client.SendAsync(httpRequestMessage).ConfigureAwait(false);
+        // Assert
+        httpResponseMessage.StatusCode.Should().Be(HttpStatusCode.NotFound);

-            // Assert
-            Check.That(httpResponseMessage.StatusCode).Equals(HttpStatusCode.NotFound);
-            Check.That(server.LogEntries.Count().Equals(1));
-
-            // Verify
-            filesystemHandlerMock.Verify(fs => fs.FileExists(It.IsAny<string>()), Times.Once);
-            filesystemHandlerMock.VerifyNoOtherCalls();
-        }
+        // Verify
+        filesystemHandlerMock.Verify(fs => fs.FileExists(It.IsAny<string>()), Times.Once);
+        filesystemHandlerMock.VerifyNoOtherCalls();
    }
 }
--- a/test/WireMock.Net.Tests/WireMockServer.WebhookTests.cs
+++ b/test/WireMock.Net.Tests/WireMockServer.WebhookTests.cs
@@ -4,10 +4,13 @@ using System.Net;
 using System.Net.Http;
 using System.Threading.Tasks;
 using FluentAssertions;
+using Moq;
+using WireMock.Logging;
 using WireMock.Models;
 using WireMock.RequestBuilders;
 using WireMock.ResponseBuilders;
 using WireMock.Server;
+using WireMock.Settings;
 using WireMock.Types;
 using WireMock.Util;
 using Xunit;
@@ -71,7 +74,7 @@ public class WireMockServerWebhookTests

        // Assert
        var response = await new HttpClient().SendAsync(request).ConfigureAwait(false);
-        string content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+        var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);

        response.StatusCode.Should().Be(HttpStatusCode.OK);
        content.Should().Be("a-response");
@@ -120,7 +123,7 @@ public class WireMockServerWebhookTests

        // Assert
        var response = await new HttpClient().SendAsync(request).ConfigureAwait(false);
-        string content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+        var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);

        response.StatusCode.Should().Be(HttpStatusCode.OK);
        content.Should().Be("a-response");
@@ -132,6 +135,115 @@ public class WireMockServerWebhookTests
        serverReceivingTheWebhook.Dispose();
    }

+    [Fact]
+    public async Task WireMockServer_WithWebhook_When_WebhookEndPointReturnsError_Should_LogWarning()
+    {
+        // Arrange
+        var serverReceivingTheWebhook = WireMockServer.Start();
+        serverReceivingTheWebhook.Given(Request.Create().WithPath("/x").UsingPost()).RespondWith(Response.Create().WithBody("!Server Error!").WithStatusCode(500));
+
+        var loggerMock = new Mock<IWireMockLogger>();
+        var settings = new WireMockServerSettings
+        {
+            Logger = loggerMock.Object
+        };
+
+        // Act
+        var guid = "942cb963-c9a3-4e9c-8e71-c1b26d2a4a05";
+        var server = WireMockServer.Start(settings);
+        server.Given(Request.Create().UsingPost())
+            .WithWebhook(new Webhook
+            {
+                Request = new WebhookRequest
+                {
+                    Url = serverReceivingTheWebhook.Url! + "/{{request.Query.q}}",
+                    Method = "post",
+                    BodyData = new BodyData
+                    {
+                        BodyAsString = "abc",
+                        DetectedBodyType = BodyType.String,
+                        DetectedBodyTypeFromContentType = BodyType.String
+                    },
+                    UseTransformer = true
+                }
+            })
+            .WithGuid(guid)
+            .RespondWith(Response.Create().WithBody("a-response"));
+
+        var request = new HttpRequestMessage
+        {
+            Method = HttpMethod.Post,
+            RequestUri = new Uri($"{server.Urls[0]}/TST?q=x"),
+            Content = new StringContent("test")
+        };
+
+        // Assert
+        var response = await new HttpClient().SendAsync(request).ConfigureAwait(false);
+        var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+
+        response.StatusCode.Should().Be(HttpStatusCode.OK);
+        content.Should().Be("a-response");
+
+        loggerMock.Verify(l => l.Warn("Sending message to Webhook [0] from Mapping '942cb963-c9a3-4e9c-8e71-c1b26d2a4a05' failed. HttpStatusCode: InternalServerError Content: !Server Error!"));
+
+        serverReceivingTheWebhook.LogEntries.Should().HaveCount(1);
+        serverReceivingTheWebhook.LogEntries.First().MappingGuid.Should().NotBeNull();
+
+        server.Dispose();
+        serverReceivingTheWebhook.Dispose();
+    }
+
+    [Fact]
+    public async Task WireMockServer_WithWebhook_When_WebhookEndPointDoesNotExists_Should_LogError()
+    {
+        // Arrange
+        var loggerMock = new Mock<IWireMockLogger>();
+        var settings = new WireMockServerSettings
+        {
+            Logger = loggerMock.Object
+        };
+
+        // Act
+        var guid = "942cb963-c9a3-4e9c-8e71-c1b26d2a4a05";
+        var server = WireMockServer.Start(settings);
+        server.Given(Request.Create().UsingPost())
+            .WithWebhook(new Webhook
+            {
+                Request = new WebhookRequest
+                {
+                    Url = "http://error-not-does-exist-" + Guid.NewGuid(),
+                    Method = "post",
+                    BodyData = new BodyData
+                    {
+                        BodyAsString = "abc",
+                        DetectedBodyType = BodyType.String,
+                        DetectedBodyTypeFromContentType = BodyType.String
+                    },
+                    UseTransformer = true
+                }
+            })
+            .WithGuid(guid)
+            .RespondWith(Response.Create().WithBody("a-response"));
+
+        var request = new HttpRequestMessage
+        {
+            Method = HttpMethod.Post,
+            RequestUri = new Uri(server.Urls[0]),
+            Content = new StringContent("test")
+        };
+
+        // Assert
+        var response = await new HttpClient().SendAsync(request).ConfigureAwait(false);
+        var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+
+        response.StatusCode.Should().Be(HttpStatusCode.OK);
+        content.Should().Be("a-response");
+
+        loggerMock.Verify(l => l.Error(It.Is<string>(formatString => formatString.Contains("Sending message to Webhook [0] from Mapping '942cb963-c9a3-4e9c-8e71-c1b26d2a4a05' failed. Exception"))));
+
+        server.Dispose();
+    }
+
    [Fact]
    public async Task WireMockServer_WithWebhookArgs_Should_Send_StringMessage_To_Webhook()
    {
@@ -142,7 +254,7 @@ public class WireMockServerWebhookTests
        // Act
        var server = WireMockServer.Start();
        server.Given(Request.Create().UsingPost())
-            .WithWebhook(serverReceivingTheWebhook.Urls[0], "post", null, "OK !", true, TransformerType.Handlebars)
+            .WithWebhook(serverReceivingTheWebhook.Urls[0], "post", null, "OK !")
            .RespondWith(Response.Create().WithBody("a-response"));

        var request = new HttpRequestMessage
@@ -154,7 +266,7 @@ public class WireMockServerWebhookTests

        // Assert
        var response = await new HttpClient().SendAsync(request).ConfigureAwait(false);
-        string content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+        var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);

        response.StatusCode.Should().Be(HttpStatusCode.OK);
        content.Should().Be("a-response");
@@ -176,7 +288,7 @@ public class WireMockServerWebhookTests
        // Act
        var server = WireMockServer.Start();
        server.Given(Request.Create().UsingPost())
-            .WithWebhook(serverReceivingTheWebhook.Urls[0], "post", null, new { Status = "OK" }, true, TransformerType.Handlebars)
+            .WithWebhook(serverReceivingTheWebhook.Urls[0], "post", null, new { Status = "OK" })
            .RespondWith(Response.Create().WithBody("a-response"));

        var request = new HttpRequestMessage
@@ -188,7 +300,7 @@ public class WireMockServerWebhookTests

        // Assert
        var response = await new HttpClient().SendAsync(request).ConfigureAwait(false);
-        string content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+        var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);

        response.StatusCode.Should().Be(HttpStatusCode.OK);
        content.Should().Be("a-response");
Author	SHA1	Message	Date
Stef Heyenrath	9443e4f071	1.5.30	2023-06-28 08:12:10 +02:00
dependabot[bot]	7a914481e5	Bump System.Linq.Dynamic.Core (#963 ) Bumps [System.Linq.Dynamic.Core](https://github.com/zzzprojects/System.Linq.Dynamic.Core) from 1.2.23 to 1.3.0. - [Release notes](https://github.com/zzzprojects/System.Linq.Dynamic.Core/releases) - [Changelog](https://github.com/zzzprojects/System.Linq.Dynamic.Core/blob/master/CHANGELOG.md) - [Commits](https://github.com/zzzprojects/System.Linq.Dynamic.Core/compare/v1.2.23...v1.3.0) --- updated-dependencies: - dependency-name: System.Linq.Dynamic.Core dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2023-06-28 07:58:03 +02:00
dependabot[bot]	1ad836659d	Bump System.Linq.Dynamic.Core (#962 ) Bumps [System.Linq.Dynamic.Core](https://github.com/zzzprojects/System.Linq.Dynamic.Core) from 1.2.23 to 1.3.0. - [Release notes](https://github.com/zzzprojects/System.Linq.Dynamic.Core/releases) - [Changelog](https://github.com/zzzprojects/System.Linq.Dynamic.Core/blob/master/CHANGELOG.md) - [Commits](https://github.com/zzzprojects/System.Linq.Dynamic.Core/compare/v1.2.23...v1.3.0) --- updated-dependencies: - dependency-name: System.Linq.Dynamic.Core dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2023-06-28 07:57:50 +02:00
Stef Heyenrath	ed7f9c1143	Add unit-test for Param - MatcherModel - LinqMatcher (#961 )	2023-06-27 22:31:14 +02:00
Stef Heyenrath	c92183558b	Fixed logic for FluentAssertions WithHeader (#959 )	2023-06-23 15:20:57 +02:00
Stef Heyenrath	8ce24249d0	1.5.29	2023-06-22 19:02:10 +02:00
Stef Heyenrath	7ca70309cb	Support setting WireMockServerSettings via Environment (#954 ) * Support parsing environment variables (WireMockServerSettings__) * case ignore * fix * SimpleSettingsParserTests * . * int * more test	2023-06-22 10:35:21 +02:00
Stef Heyenrath	5d0bf6f4e1	Fix some SonarCloud issues (#955 ) * Fixed some SonarCloud issues * if (value.Contains('\n'))	2023-06-13 19:31:04 +02:00
Stef Heyenrath	f6e35cbe2d	1.5.28	2023-06-11 14:22:54 +02:00
Stef Heyenrath	dc4c8d1dba	WireMock.Net.Testcontainers (#948 ) * WireMock.Net.Testcontainers * . * logger? * . * . * WatchStaticMappings * linux * . * -- * ContainerInfo * . * 02 * . * fix * .	2023-06-11 13:55:57 +02:00
Stef Heyenrath	adf1914877	Allow setting the Content-Length header for a HTTP method HEAD (#951 ) * Allow setting the Content-Length header for a HTTP method HEAD * .	2023-06-06 22:44:14 +02:00
Stef Heyenrath	1f1bc05f00	1.5.27	2023-06-03 17:00:18 +02:00
Stef Heyenrath	c107e38e3b	Fix WireMock.Net.FluentAssertions for net47	2023-06-02 12:03:12 +02:00
Stef Heyenrath	a77c4fe1ac	Add ".NET Framework 4.7" to WireMock.Net.FluentAssertions (#949 )	2023-06-01 18:06:28 +02:00
Stef Heyenrath	c1e71707c5	Add warning logging when sending a request to a Webhook does not return status 200 (#946 )	2023-05-28 10:53:54 +02:00
Oleg Nenashev	69499afe43	Update Slack link (#944 ) Better to use https://slack.wiremock.org/ to have proper Slack signup	2023-05-26 10:01:16 +02:00
Stef Heyenrath	aadac78577	add Slack	2023-05-25 23:49:12 +02:00
Stef Heyenrath	71393204cc	1.5.26	2023-05-25 21:36:01 +02:00
Cezary Piątek	e5cc6f570c	Code generator improvements (#940 ) * Fix quotation marks escaping in multiline string * Add support for JsonPartialMatcher and JsonPartialWildcardMatcher in mapping code generator	2023-05-25 20:59:13 +02:00
Stef Heyenrath	7c3a0c815d	Add GetParameter method to IRequestMessage (#942 )	2023-05-25 15:14:02 +02:00
Stef Heyenrath	e61f08fe48	WireMockMiddleware should use HandleRequestsSynchronously correctly (#939 )	2023-05-19 21:43:14 +02:00
Stef Heyenrath	11f4c47851	Add more unitests for CSharpFormatter utils (#938 ) * Add unit-tests for CSharpFormatter * . * t	2023-05-19 16:14:26 +02:00