1.5.28

WireMock.Net.Testcontainers (#948 )
* WireMock.Net.Testcontainers * . * logger? * . * . * WatchStaticMappings * linux * . * -- * ContainerInfo * . * 02 * . * fix * .
2026-02-10 04:17:41 +01:00 · 2023-06-11 14:22:54 +02:00 · 2023-06-11 13:55:57 +02:00 · 2023-06-06 22:44:14 +02:00 · 2023-06-03 17:00:18 +02:00 · 2023-06-02 12:03:12 +02:00
37 changed files with 1308 additions and 97 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,30 @@
+# 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)
+
+# 1.5.24 (07 May 2023)
+- [#926](https://github.com/WireMock-Net/WireMock.Net/pull/926) - Fix C# mapping code generator for header names [bug] contributed by [cezarypiatek](https://github.com/cezarypiatek)
+- [#927](https://github.com/WireMock-Net/WireMock.Net/pull/927) - Enrich generated code with status code [feature] contributed by [cezarypiatek](https://github.com/cezarypiatek)
+- [#930](https://github.com/WireMock-Net/WireMock.Net/pull/930) - Update C# mapping code generator for WithStatusCode [feature] contributed by [StefH](https://github.com/StefH)
+- [#931](https://github.com/WireMock-Net/WireMock.Net/pull/931) - Add property 'IsStartedWithAdminInterface' to 'IWireMockServer' [feature] contributed by [StefH](https://github.com/StefH)
+- [#933](https://github.com/WireMock-Net/WireMock.Net/pull/933) - C# code generator improvements [feature] contributed by [cezarypiatek](https://github.com/cezarypiatek)
+
 # 1.5.23 (23 April 2023)
 - [#922](https://github.com/WireMock-Net/WireMock.Net/pull/922) - Add WithProbability [feature] contributed by [StefH](https://github.com/StefH)
 - [#924](https://github.com/WireMock-Net/WireMock.Net/pull/924) - Allow removal of prefix when proxying to another server (#630) [feature] contributed by [nudejustin](https://github.com/nudejustin)
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -4,7 +4,7 @@
    </PropertyGroup>

    <PropertyGroup>
-        <VersionPrefix>1.5.23</VersionPrefix>
+        <VersionPrefix>1.5.28</VersionPrefix>
        <PackageIcon>WireMock.Net-Logo.png</PackageIcon>
        <PackageProjectUrl>https://github.com/WireMock-Net/WireMock.Net</PackageProjectUrl>
        <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>
@@ -12,6 +12,7 @@
        <RepositoryType>git</RepositoryType>
        <RepositoryUrl>https://github.com/WireMock-Net/WireMock.Net</RepositoryUrl>
        <ApplicationIcon>../../resources/WireMock.Net-Logo.ico</ApplicationIcon>
+        <PackageReadmeFile>PackageReadme.md</PackageReadmeFile>
        <LangVersion>Latest</LangVersion>
        <Nullable>enable</Nullable>
    </PropertyGroup>
@@ -29,7 +30,7 @@

    <ItemGroup>
        <None Include="../../resources/WireMock.Net-Logo.png" Pack="true" PackagePath="" />
-        <!--<None Include="../../PackageReadme.md" Pack="true" PackagePath=""/>-->
+        <None Include="../../PackageReadme.md" Pack="true" PackagePath=""/>
    </ItemGroup>

    <Choose>
--- a/Generate-ReleaseNotes.cmd
+++ b/Generate-ReleaseNotes.cmd
@@ -1,6 +1,6 @@
 rem https://github.com/StefH/GitHubReleaseNotes

-SET version=1.5.23
+SET version=1.5.28

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

--- a/PackageReadme.md
+++ b/PackageReadme.md
@@ -0,0 +1,55 @@
+## WireMock.Net
+Lightweight Http Mocking Server for .NET, inspired by [WireMock(http://WireMock.org) from the Java landscape.
+
+### :star: Key Features
+* HTTP response stubbing, matchable on URL/Path, headers, cookies and body content patterns
+* Library can be used in unit tests and integration tests
+* Runs as a standalone process, as windows service, as Azure/IIS or as docker
+* Configurable via a fluent C# .NET API, JSON files and JSON over HTTP
+* Record/playback of stubs (proxying)
+* Per-request conditional proxying
+* Stateful behaviour simulation
+* Response templating / transformation using Handlebars and extensions
+* Can be used locally or in CI/CD scenarios
+
+### :star: Stubbing
+A core feature of WireMock.Net is the ability to return predefined HTTP responses for requests matching criteria.
+See [Wiki : Stubbing](https://github.com/WireMock-Net/WireMock.Net/wiki/Stubbing).
+
+### :star: Request Matching
+WireMock.Net support advanced request-matching logic, see [Wiki : Request Matching](https://github.com/WireMock-Net/WireMock.Net/wiki/Request-Matching).
+
+### :star: Response Templating
+The response which is returned WireMock.Net can be changed using templating. This is described here [Wiki : Response Templating](https://github.com/WireMock-Net/WireMock.Net/wiki/Response-Templating).
+
+### :star: Admin API Reference
+The WireMock admin API provides functionality to define the mappings via a http interface see [Wiki : Admin API Reference](https://github.com/StefH/WireMock.Net/wiki/Admin-API-Reference).
+
+### :star: Using
+WireMock.Net can be used in several ways:
+
+#### UnitTesting
+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).
+
+#### 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).
+
+#### As a Web Job in Azure or application in IIS
+See this link [WireMock-as-a-(Azure)-Web-App](https://github.com/WireMock-Net/WireMock.Net/wiki/WireMock-as-a-(Azure)-Web-App)
+
+#### In a docker container
+There is also a Linux and Windows-Nano container available at [hub.docker.com](https://hub.docker.com/r/sheyenrath).
+For more details see also [Docker](https://github.com/WireMock-Net/WireMock.Net-docker).
+
+#### HTTPS / SSL
+More details on using HTTPS (SSL) can be found here [Wiki : HTTPS](https://github.com/WireMock-Net/WireMock.Net/wiki/Using-HTTPS-(SSL))
+
+## :books: Documentation
+For more info, see also this WIKI page: [What is WireMock.Net](https://github.com/WireMock-Net/WireMock.Net/wiki/What-Is-WireMock.Net).
--- a/PackageReleaseNotes.txt
+++ b/PackageReleaseNotes.txt
@@ -1,6 +1,5 @@
-# 1.5.23 (23 April 2023)
- #922 Add WithProbability [feature]
- #924 Allow removal of prefix when proxying to another server (#630) [feature]
- #925 Add IgnoreCase option to ProxyUrlReplaceSettings [feature]
+# 1.5.28 (11 June 2023)
+- #948 WireMock.Net.Testcontainers [feature]
+- #951 Allow setting the Content-Length header for a HTTP method HEAD [feature]

 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
@@ -1,28 +1,28 @@
 # WireMock.Net
-A C# .NET version based on [mock4net](https://github.com/alexvictoor/mock4net) which mimics the functionality from the JAVA based [WireMock.org](http://WireMock.org).
+A C# .NET version based on [mock4net](https://github.com/alexvictoor/mock4net) which mimics the functionality from the JAVA based [WireMock](http://WireMock.org).

 For more info, see also this WIKI page: [What is WireMock.Net](https://github.com/WireMock-Net/WireMock.Net/wiki/What-Is-WireMock.Net).

-## Key Features
+## :star: Key Features
 * HTTP response stubbing, matchable on URL/Path, headers, cookies and body content patterns
 * Library can be used in unit tests and integration tests
 * Runs as a standalone process, as windows service, as Azure/IIS or as docker
-* Configurable via a fluent DotNet API, JSON files and JSON over HTTP
+* Configurable via a fluent C# .NET API, JSON files and JSON over HTTP
 * Record/playback of stubs (proxying)
 * Per-request conditional proxying
 * Stateful behaviour simulation
 * Response templating / transformation using Handlebars and extensions
 * Can be used locally or in CI/CD scenarios

-## Blogs
+## :memo: Blogs
 - [mStack.nl : Generate C# Code from Mapping(s)](https://mstack.nl/blog/20230201-wiremock.net-tocode/)


-## Project Info
+## :computer: Project Info
 | | |
 | --- | --- |
 | ***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; |
@@ -31,7 +31,7 @@ For more info, see also this WIKI page: [What is WireMock.Net](https://github.co
 | &nbsp;&nbsp;**Sonar Bugs** | [![Sonar Bugs](https://sonarcloud.io/api/project_badges/measure?project=WireMock-Net_WireMock.Net&metric=bugs)](https://sonarcloud.io/project/issues?id=WireMock-Net_WireMock.Net&resolved=false&types=BUG) [![Sonar Code Smells](https://sonarcloud.io/api/project_badges/measure?project=WireMock-Net_WireMock.Net&metric=code_smells)](https://sonarcloud.io/project/issues?id=WireMock-Net_WireMock.Net&resolved=false&types=CODE_SMELL) |
 | &nbsp;&nbsp;**Coverage** | [![Sonar Coverage](https://sonarcloud.io/api/project_badges/measure?project=WireMock-Net_WireMock.Net&metric=coverage)](https://sonarcloud.io/component_measures?id=WireMock-Net_WireMock.Net&metric=coverage) [![codecov](https://codecov.io/gh/WireMock-Net/WireMock.Net/branch/master/graph/badge.svg)](https://codecov.io/gh/WireMock-Net/WireMock.Net)|

-### NuGet packages
+### :package: NuGet packages

 | | Official | Preview [:information_source:](https://github.com/WireMock-Net/WireMock.Net/wiki/MyGet-preview-versions) |
 | - | - | - |
@@ -42,39 +42,42 @@ 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)


-## Development
+## :memo: Development
 For the supported frameworks and build information, see [this](https://github.com/WireMock-Net/WireMock.Net/wiki/Development-Information) page.

-## Stubbing
+## :star: Stubbing
 A core feature of WireMock.Net is the ability to return predefined HTTP responses for requests matching criteria.
 See [Wiki : Stubbing](https://github.com/WireMock-Net/WireMock.Net/wiki/Stubbing).

-## Request Matching
+## :star: Request Matching
 WireMock.Net support advanced request-matching logic, see [Wiki : Request Matching](https://github.com/WireMock-Net/WireMock.Net/wiki/Request-Matching).

-## Response Templating
+## :star: Response Templating
 The response which is returned WireMock.Net can be changed using templating. This is described here [Wiki : Response Templating](https://github.com/WireMock-Net/WireMock.Net/wiki/Response-Templating).

-## Admin API Reference
+## :star: Admin API Reference
 The WireMock admin API provides functionality to define the mappings via a http interface see [Wiki : Admin API Reference](https://github.com/StefH/WireMock.Net/wiki/Admin-API-Reference).

-## Using
+## :star: Using
 WireMock.Net can be used in several ways:

 ### UnitTesting
 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
@@ -28,6 +28,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		.github\FUNDING.yml = .github\FUNDING.yml
 		Generate-ReleaseNotes.cmd = Generate-ReleaseNotes.cmd
 		nuget.config = nuget.config
+		PackageReadme.md = PackageReadme.md
 		PackageReleaseNotes.template = PackageReleaseNotes.template
 		PackageReleaseNotes.txt = PackageReleaseNotes.txt
 		README.md = README.md
@@ -110,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
@@ -264,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
@@ -308,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.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.Abstractions/Server/IWireMockServer.cs
+++ b/src/WireMock.Net.Abstractions/Server/IWireMockServer.cs
@@ -17,6 +17,11 @@ public interface IWireMockServer : IDisposable
    /// </summary>
    bool IsStarted { get; }

+    /// <summary>
+    /// Gets a value indicating whether this server is started with the admin interface enabled.
+    /// </summary>
+    bool IsStartedWithAdminInterface { get; }
+
    /// <summary>
    /// Gets the request logs.
    /// </summary>
--- 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.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/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
@@ -1,9 +1,10 @@
 using System;
 using System.Collections.Generic;
-using System.Globalization;
 using System.Linq;
+using System.Net;
 using System.Text;
 using System.Threading;
+using Newtonsoft.Json;
 using Stef.Validation;
 using WireMock.Admin.Mappings;
 using WireMock.Constants;
@@ -17,6 +18,7 @@ using WireMock.Settings;
 using WireMock.Types;
 using WireMock.Util;

+using static WireMock.Util.CSharpFormatter;
 namespace WireMock.Serialization;

 internal class MappingConverter
@@ -105,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(@"    )");
@@ -125,21 +144,42 @@ internal class MappingConverter
        // Response
        sb.AppendLine("    .RespondWith(Response.Create()");

+        if (response.ResponseMessage.StatusCode is int or string)
+        {
+            sb.AppendLine($"        .WithStatusCode({JsonConvert.SerializeObject(response.ResponseMessage.StatusCode)})");
+        }
+        else if (response.ResponseMessage.StatusCode is HttpStatusCode httpStatusCode)
+        {
+            sb.AppendLine($"        .WithStatusCode({(int)httpStatusCode})");
+        }
+
        if (response.ResponseMessage.Headers is { })
        {
            foreach (var header in response.ResponseMessage.Headers)
            {
-                sb.AppendLine($"        .WithHeader(\"{header.Key})\", {ToValueArguments(header.Value.ToArray())})");
+                sb.AppendLine($"        .WithHeader(\"{header.Key}\", {ToValueArguments(header.Value.ToArray())})");
            }
        }

-        if (response.ResponseMessage.BodyData is { })
+        if (response.ResponseMessage.BodyData is { } bodyData)
        {
            switch (response.ResponseMessage.BodyData.DetectedBodyType)
            {
                case BodyType.String:
                case BodyType.FormUrlEncoded:
-                    sb.AppendLine($"        .WithBody(\"{response.ResponseMessage.BodyData.BodyAsString}\")");
+                    sb.AppendLine($"        .WithBody({ToCSharpStringLiteral(bodyData.BodyAsString)})");
+                    break;
+                case BodyType.Json:
+                    if (bodyData.BodyAsJson is string bodyStringValue)
+                    {
+                        sb.AppendLine($"        .WithBody({ToCSharpStringLiteral(bodyStringValue)})");
+                    }
+                    else if(bodyData.BodyAsJson is {} jsonBody)
+                    {
+                        var anonymousObjectDefinition = ConvertToAnonymousObjectDefinition(jsonBody);
+                        sb.AppendLine($"        .WithBodyAsJson({anonymousObjectDefinition})");
+                    }
+
                    break;
            }
        }
@@ -382,7 +422,7 @@ internal class MappingConverter

    private static string GetString(IStringMatcher stringMatcher)
    {
-        return stringMatcher.GetPatterns().Select(p => $"\"{p.GetPattern()}\"").First();
+        return stringMatcher.GetPatterns().Select(p => ToCSharpStringLiteral(p.GetPattern())).First();
    }

    private static string[] GetStringArray(IReadOnlyList<IStringMatcher> stringMatchers)
@@ -435,7 +475,7 @@ internal class MappingConverter

    private static string ToValueArguments(string[]? values, string defaultValue = "")
    {
-        return values is { } ? string.Join(", ", values.Select(v => $"\"{v}\"")) : $"\"{defaultValue}\"";
+        return values is { } ? string.Join(", ", values.Select(ToCSharpStringLiteral)) : ToCSharpStringLiteral(defaultValue);
    }

    private static WebProxyModel? MapWebProxy(WebProxySettings? settings)
@@ -466,4 +506,6 @@ internal class MappingConverter

        return newDictionary;
    }
+
+
 }
--- a/src/WireMock.Net/Server/WireMockServer.cs
+++ b/src/WireMock.Net/Server/WireMockServer.cs
@@ -43,10 +43,14 @@ public partial class WireMockServer : IWireMockServer
    private readonly IGuidUtils _guidUtils = new GuidUtils();
    private readonly IDateTimeUtils _dateTimeUtils = new DateTimeUtils();

-    /// <inheritdoc cref="IWireMockServer.IsStarted" />
+    /// <inheritdoc />
    [PublicAPI]
    public bool IsStarted => _httpServer is { IsStarted: true };

+    /// <inheritdoc />
+    [PublicAPI]
+    public bool IsStartedWithAdminInterface => IsStarted && _settings.StartAdminInterface.GetValueOrDefault();
+
    /// <inheritdoc />
    [PublicAPI]
    public List<int> Ports { get; }
--- a/src/WireMock.Net/Util/CSharpFormatter.cs
+++ b/src/WireMock.Net/Util/CSharpFormatter.cs
@@ -0,0 +1,180 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace WireMock.Util;
+
+internal static class CSharpFormatter
+{
+    #region Reserved Keywords
+    private static readonly HashSet<string> CSharpReservedKeywords = new(new[]
+    {
+        "abstract",
+        "as",
+        "base",
+        "bool",
+        "break",
+        "byte",
+        "case",
+        "catch",
+        "char",
+        "checked",
+        "class",
+        "const",
+        "continue",
+        "decimal",
+        "default",
+        "delegate",
+        "do",
+        "double",
+        "else",
+        "enum",
+        "event",
+        "explicit",
+        "extern",
+        "false",
+        "finally",
+        "fixed",
+        "float",
+        "for",
+        "foreach",
+        "goto",
+        "if",
+        "implicit",
+        "in",
+        "int",
+        "interface",
+        "internal",
+        "is",
+        "lock",
+        "long",
+        "namespace",
+        "new",
+        "null",
+        "object",
+        "operator",
+        "out",
+        "override",
+        "params",
+        "private",
+        "protected",
+        "public",
+        "readonly",
+        "ref",
+        "return",
+        "sbyte",
+        "sealed",
+        "short",
+        "sizeof",
+        "stackalloc",
+        "static",
+        "string",
+        "struct",
+        "switch",
+        "this",
+        "throw",
+        "true",
+        "try",
+        "typeof",
+        "uint",
+        "ulong",
+        "unchecked",
+        "unsafe",
+        "ushort",
+        "using",
+        "virtual",
+        "void",
+        "volatile",
+        "while"
+    });
+    #endregion
+
+    private const string Null = "null";
+
+    public static object ConvertToAnonymousObjectDefinition(object jsonBody)
+    {
+        var serializedBody = JsonConvert.SerializeObject(jsonBody);
+        using var jsonReader = new JsonTextReader(new StringReader(serializedBody));
+        jsonReader.DateParseHandling = DateParseHandling.None;
+        var deserializedBody = JObject.Load(jsonReader);
+
+        return ConvertJsonToAnonymousObjectDefinition(deserializedBody, 2);
+    }
+
+    public static string ConvertJsonToAnonymousObjectDefinition(JToken token, int ind = 0)
+    {
+        return token switch
+        {
+            JArray jArray => FormatArray(jArray, ind),
+            JObject jObject => FormatObject(jObject, ind),
+            JProperty jProperty => $"{FormatPropertyName(jProperty.Name)} = {ConvertJsonToAnonymousObjectDefinition(jProperty.Value, ind)}",
+            JValue jValue => jValue.Type switch
+            {
+                JTokenType.None => Null,
+                JTokenType.Integer => jValue.Value != null ? string.Format(CultureInfo.InvariantCulture, "{0}", jValue.Value) : Null,
+                JTokenType.Float => jValue.Value != null ? string.Format(CultureInfo.InvariantCulture, "{0}", jValue.Value) : Null,
+                JTokenType.String => ToCSharpStringLiteral(jValue.Value?.ToString()),
+                JTokenType.Boolean => jValue.Value != null ? string.Format(CultureInfo.InvariantCulture, "{0}", jValue.Value).ToLower() : Null,
+                JTokenType.Null => Null,
+                JTokenType.Undefined => Null,
+                JTokenType.Date when jValue.Value is DateTime dateValue =>
+                    $"DateTime.Parse({ToCSharpStringLiteral(dateValue.ToString("s"))})",
+                _ => $"UNHANDLED_CASE: {jValue.Type}"
+            },
+            _ => $"UNHANDLED_CASE: {token}"
+        };
+    }
+
+    public static string ToCSharpBooleanLiteral(bool value) => value ? "true" : "false";
+
+    public static string ToCSharpStringLiteral(string? value)
+    {
+        if (string.IsNullOrEmpty(value))
+        {
+            return "\"\"";
+        }
+
+        if (value.Contains("\n"))
+        {
+            var escapedValue = value?.Replace("\"", "\"\"") ?? string.Empty;
+            return $"@\"{escapedValue}\"";
+        }
+        else
+        {
+            var escapedValue = value?.Replace("\"", "\\\"") ?? string.Empty;
+            return $"\"{escapedValue}\"";
+        }
+    }
+
+    public static string FormatPropertyName(string propertyName)
+    {
+        return CSharpReservedKeywords.Contains(propertyName) ? "@" + propertyName : propertyName;
+    }
+
+    private static string FormatObject(JObject jObject, int ind)
+    {
+        var indStr = new string(' ', 4 * ind);
+        var indStrSub = new string(' ', 4 * (ind + 1));
+        var items = jObject.Properties().Select(x => ConvertJsonToAnonymousObjectDefinition(x, ind + 1));
+
+        return $"new\r\n{indStr}{{\r\n{indStrSub}{string.Join($",\r\n{indStrSub}", items)}\r\n{indStr}}}";
+    }
+
+    private static string FormatArray(JArray jArray, int ind)
+    {
+        var hasComplexItems = jArray.FirstOrDefault() is JObject or JArray;
+        var items = jArray.Select(x => ConvertJsonToAnonymousObjectDefinition(x, hasComplexItems ? ind + 1 : ind));
+        if (hasComplexItems)
+        {
+            var indStr = new string(' ', 4 * ind);
+            var indStrSub = new string(' ', 4 * (ind + 1));
+            return $"new []\r\n{indStr}{{\r\n{indStrSub}{string.Join($",\r\n{indStrSub}", items)}\r\n{indStr}}}";
+        }
+
+        return $"new [] {{ {string.Join(", ", items)} }}";
+    }
+}
--- 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/Serialization/MappingConverterTests.ToCSharpCode_With_Builder_And_AddStartIsFalse.verified.txt
+++ b/test/WireMock.Net.Tests/Serialization/MappingConverterTests.ToCSharpCode_With_Builder_And_AddStartIsFalse.verified.txt
@@ -11,7 +11,7 @@
    .WithGuid("8e7b9ab7-e18e-4502-8bc9-11e6679811cc")
    .WithProbability(0.3)
    .RespondWith(Response.Create()
-        .WithHeader("Keep-Alive)", "test")
+        .WithHeader("Keep-Alive", "test")
        .WithBody("bbb")
        .WithDelay(12345)
        .WithTransformer()
--- a/test/WireMock.Net.Tests/Serialization/MappingConverterTests.ToCSharpCode_With_Builder_And_AddStartIsTrue.verified.txt
+++ b/test/WireMock.Net.Tests/Serialization/MappingConverterTests.ToCSharpCode_With_Builder_And_AddStartIsTrue.verified.txt
@@ -12,7 +12,7 @@ builder
    .WithGuid("8e7b9ab7-e18e-4502-8bc9-11e6679811cc")
    .WithProbability(0.3)
    .RespondWith(Response.Create()
-        .WithHeader("Keep-Alive)", "test")
+        .WithHeader("Keep-Alive", "test")
        .WithBody("bbb")
        .WithDelay(12345)
        .WithTransformer()
--- a/test/WireMock.Net.Tests/Serialization/MappingConverterTests.ToCSharpCode_With_Server_And_AddStartIsFalse.verified.txt
+++ b/test/WireMock.Net.Tests/Serialization/MappingConverterTests.ToCSharpCode_With_Server_And_AddStartIsFalse.verified.txt
@@ -11,7 +11,7 @@
    .WithGuid("8e7b9ab7-e18e-4502-8bc9-11e6679811cc")
    .WithProbability(0.3)
    .RespondWith(Response.Create()
-        .WithHeader("Keep-Alive)", "test")
+        .WithHeader("Keep-Alive", "test")
        .WithBody("bbb")
        .WithDelay(12345)
        .WithTransformer()
--- a/test/WireMock.Net.Tests/Serialization/MappingConverterTests.ToCSharpCode_With_Server_And_AddStartIsTrue.verified.txt
+++ b/test/WireMock.Net.Tests/Serialization/MappingConverterTests.ToCSharpCode_With_Server_And_AddStartIsTrue.verified.txt
@@ -12,7 +12,7 @@ server
    .WithGuid("8e7b9ab7-e18e-4502-8bc9-11e6679811cc")
    .WithProbability(0.3)
    .RespondWith(Response.Create()
-        .WithHeader("Keep-Alive)", "test")
+        .WithHeader("Keep-Alive", "test")
        .WithBody("bbb")
        .WithDelay(12345)
        .WithTransformer()
--- 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/WireMockAdminApiTests.IWireMockAdminApi_GetMappingCodeByGuidAsync.verified.txt
+++ b/test/WireMock.Net.Tests/WireMockAdminApiTests.IWireMockAdminApi_GetMappingCodeByGuidAsync.verified.txt
@@ -7,5 +7,6 @@ server
    )
    .WithGuid("90356dba-b36c-469a-a17e-669cd84f1f05")
    .RespondWith(Response.Create()
+        .WithStatusCode(200)
        .WithBody("1")
    );
--- a/test/WireMock.Net.Tests/WireMockAdminApiTests.IWireMockAdminApi_GetMappingsCode.verified.txt
+++ b/test/WireMock.Net.Tests/WireMockAdminApiTests.IWireMockAdminApi_GetMappingsCode.verified.txt
@@ -7,18 +7,84 @@ server
    )
    .WithGuid("90356dba-b36c-469a-a17e-669cd84f1f05")
    .RespondWith(Response.Create()
+        .WithStatusCode(200)
        .WithBody("1")
    );

 server
    .Given(Request.Create()
-        .UsingMethod("GET")
+        .UsingMethod("POST")
        .WithPath("/foo2")
        .WithParam("p2", "abc")
+        .WithHeader("h1", "W/\"234f2q3r\"", true)
    )
    .WithGuid("1b731398-4a5b-457f-a6e3-d65e541c428f")
    .RespondWith(Response.Create()
-        .WithHeader("hk)", "hv")
+        .WithStatusCode("201")
+        .WithHeader("hk", "hv")
+        .WithHeader("ETag", "W/\"168d8e\"")
        .WithBody("2")
    );

+server
+    .Given(Request.Create()
+        .UsingMethod("DELETE")
+        .WithUrl("https://localhost/test")
+    )
+    .WithGuid("f74fd144-df53-404f-8e35-da22a640bd5f")
+    .RespondWith(Response.Create()
+        .WithStatusCode(208)
+        .WithBodyAsJson(new
+        {
+            @as = 1,
+            b = 1.2,
+            d = true,
+            e = false,
+            f = new [] { 1, 2, 3, 4 },
+            g = new
+            {
+                z1 = 1,
+                z2 = 2,
+                z3 = new [] { "a", "b", "c" },
+                z4 = new []
+                {
+                    new
+                    {
+                        a = 1,
+                        b = 2
+                    },
+                    new
+                    {
+                        a = 2,
+                        b = 3
+                    }
+                }
+            },
+            date_field = "2023-05-08T11:20:19",
+            string_field_with_date = "2021-03-13T21:04:00Z",
+            multiline_text = @"This
+is
+multiline
+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
@@ -2,6 +2,7 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Net;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Text;
@@ -17,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;
@@ -717,6 +719,8 @@ public class WireMockAdminApiTests
        // Arrange
        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
@@ -738,21 +742,54 @@ public class WireMockAdminApiTests
                Request.Create()
                    .WithPath("/foo2")
                    .WithParam("p2", "abc")
-                    .UsingGet()
+                    .WithHeader("h1", "W/\"234f2q3r\"")
+                    .UsingPost()
            )
            .WithGuid(guid2)
            .RespondWith(
                Response.Create()
-                    .WithStatusCode(201)
+                    .WithStatusCode("201")
                    .WithHeader("hk", "hv")
+                    .WithHeader("ETag", "W/\"168d8e\"")
                    .WithBody("2")
            );

+        server
+            .Given(
+                Request.Create()
+                    .WithUrl("https://localhost/test")
+                    .UsingDelete()
+            )
+            .WithGuid(guid3)
+            .RespondWith(
+                Response.Create()
+                    .WithStatusCode(HttpStatusCode.AlreadyReported)
+                    .WithBodyAsJson(new { @as = 1, b=1.2, d=true, e=false, f=new[]{1,2,3,4}, g= new{z1=1, z2=2, z3=new []{"a","b","c"}, z4=new[]{new {a=1, b=2},new {a=2, b=3}}}, date_field = new DateTime(2023,05,08,11,20,19), string_field_with_date="2021-03-13T21:04:00Z", multiline_text= @"This
+is
+multiline
+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(2);
+        mappings.Should().HaveCount(4);

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

--- 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");
--- a/test/WireMock.Net.Tests/WireMockServerTests.cs
+++ b/test/WireMock.Net.Tests/WireMockServerTests.cs
@@ -34,6 +34,32 @@ public partial class WireMockServerTests
        _testOutputHelper = testOutputHelper;
    }

+    [Fact]
+    public void WireMockServer_Start()
+    {
+        // Act
+        var server = WireMockServer.Start();
+
+        // Assert
+        server.IsStarted.Should().BeTrue();
+        server.IsStartedWithAdminInterface.Should().BeFalse();
+
+        server.Stop();
+    }
+
+    [Fact]
+    public void WireMockServer_StartWithAdminInterface()
+    {
+        // Act
+        var server = WireMockServer.StartWithAdminInterface();
+
+        // Assert
+        server.IsStarted.Should().BeTrue();
+        server.IsStartedWithAdminInterface.Should().BeTrue();
+
+        server.Stop();
+    }
+
    [Fact]
    public async Task WireMockServer_Should_Reset_LogEntries()
    {
Author	SHA1	Message	Date
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
Stef Heyenrath	3956cd703b	1.5.25 (ReleaseNotes)	2023-05-13 11:17:03 +02:00
Stef Heyenrath	27682d0ce4	1.5.25 + Fixes in CSharpFormatter	2023-05-13 11:15:40 +02:00
Cezary Piątek	8444c8c506	Code generator improvements (#934 ) * Handle new line escaping in C# mapping code generator * Prevent date conversion when value persisted as string * Handle object properties named as csharp keywords * Refactor: Extract logic responsible for generating anonymous object definition to a separate class	2023-05-13 09:33:25 +02:00
Stef Heyenrath	6ef116a295	1.5.24	2023-05-07 14:48:20 +02:00
Stef Heyenrath	59195eaed8	Refactor some code (MappingConverter)	2023-05-07 14:42:00 +02:00
Cezary Piątek	7d9e450814	C# code generator improvements (#933 ) * Escape quotes in generated C# strings * Handle response with JSON body in C# code generator	2023-05-07 14:37:48 +02:00
Stef Heyenrath	7019a5a78c	Add Package Readme (#932 ) * Add Package Readme * C# .NET API * <PackageReadmeFile>PackageReadme.md</PackageReadmeFile>	2023-05-07 09:24:48 +02:00
Stef Heyenrath	d29f3e81f3	Add property 'IsStartedWithAdminInterface' to 'IWireMockServer' (#931 ) * Add property 'IsStartedWithAdminInterface' to 'IWireMockServer' * update tests * .	2023-05-06 13:12:00 +02:00
Stef Heyenrath	ccd8026884	Update C# mapping code generator for WithStatusCode (#930 )	2023-05-06 10:24:53 +02:00
Cezary Piątek	1214ba5108	Enrich generated code with status code (#927 )	2023-05-06 09:40:41 +02:00
Cezary Piątek	427715a38a	Fix csharp mapping code generator (#926 )	2023-05-02 16:48:32 +02:00