1.4.20

Update Handlebars.Net.Helpers.XPath to fix issue with 'xml version'

.editorconfig

@@ -0,0 +1,6 @@
+[*]
+indent_style = space
+indent_size = 4
+end_of_line = crlf
+charset = utf-8
+trim_trailing_whitespace = true

.github/FUNDING.yml

@@ -1,8 +1,8 @@
 # These are supported funding model platforms
 
-github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+github: [StefH]
 patreon: # Replace with a single Patreon username
-open_collective: # Replace with a single Open Collective username
+open_collective: # wiremocknet
 ko_fi: # Replace with a single Ko-fi username
 tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry

Directory.Build.props

@@ -4,7 +4,7 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <VersionPrefix>1.4.12</VersionPrefix>
+    <VersionPrefix>1.4.20</VersionPrefix>
     <PackageReleaseNotes>See CHANGELOG.md</PackageReleaseNotes>
     <PackageIconUrl>https://raw.githubusercontent.com/WireMock-Net/WireMock.Net/master/WireMock.Net-Logo.png</PackageIconUrl>
     <PackageProjectUrl>https://github.com/WireMock-Net/WireMock.Net</PackageProjectUrl>

GitHubReleaseNotes.txt

@@ -1,3 +1,3 @@
 https://github.com/StefH/GitHubReleaseNotes
 
-GitHubReleaseNotes --output CHANGELOG.md --skip-empty-releases --exclude-labels question invalid doc --version 1.4.12
+GitHubReleaseNotes --output CHANGELOG.md --skip-empty-releases --exclude-labels question invalid doc duplicate --version 1.4.20

README.md

@@ -36,6 +36,7 @@ For more info, see also this WIKI page: [What is WireMock.Net](https://github.co
 |   **WireMock.Net.FluentAssertions** | [![NuGet Badge WireMock.Net.FluentAssertions](https://buildstats.info/nuget/WireMock.Net.FluentAssertions)](https://www.nuget.org/packages/WireMock.Net.FluentAssertions) | [![MyGet Badge WireMock.Net.FluentAssertions](https://buildstats.info/myget/wiremock-net/WireMock.Net.FluentAssertions?includePreReleases=true)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net.FluentAssertions)
 |   **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)
 |   **WireMock.Net.Matchers.CSharpCode** | [![NuGet Badge WireMock.Net.Matchers.CSharpCode](https://buildstats.info/nuget/WireMock.Net.Matchers.CSharpCode)](https://www.nuget.org/packages/WireMock.Net.Matchers.CSharpCode) | [![MyGet Badge WireMock.Net.Matchers.CSharpCode](https://buildstats.info/myget/wiremock-net/WireMock.Net.Matchers.CSharpCode?includePreReleases=true)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net.Matchers.CSharpCode)
+|   **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)
 
 ## Development
 For the supported frameworks and build information, see [this](https://github.com/WireMock-Net/WireMock.Net/wiki/Development-Information) page.

WireMock.Net Solution.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.30114.105
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31521.260
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{8F890C6F-9ACC-438D-928A-AD61CDA862F2}"
 EndProject
@@ -21,6 +21,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "examples", "examples", "{98
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{7EFB2C5B-1BB2-4AAF-BC9F-216ED80C594D}"
 	ProjectSection(SolutionItems) = preProject
+		.editorconfig = .editorconfig
 		.gitignore = .gitignore
 		azure-pipelines-ci-linux.yml = azure-pipelines-ci-linux.yml
 		azure-pipelines-ci.yml = azure-pipelines-ci.yml

WireMock.Net Solution.sln.DotSettings

@@ -13,6 +13,9 @@
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=funcs/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Heyenrath/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Jmes/@EntryIndexedValue">True</s:Boolean>
+	<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/=Stef/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Webhook/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Webhooks/@EntryIndexedValue">True</s:Boolean>
 </wpf:ResourceDictionary>

azure-pipelines-ci.yml

@@ -28,6 +28,7 @@ jobs:
   
   - task: SonarCloudPrepare@1
     displayName: 'Prepare analysis on SonarCloud'
+    condition: and(succeeded(), ne(variables['Build.Reason'], 'PullRequest')) # Do not run for PullRequests
     inputs:
       SonarCloud: SonarCloud
       organization: wiremock-net
@@ -52,9 +53,11 @@ jobs:
   
   - task: SonarCloudAnalyze@1
     displayName: 'SonarCloud: Run Code Analysis'
+    condition: and(succeeded(), ne(variables['Build.Reason'], 'PullRequest')) # Do not run for PullRequests
   
   - task: SonarCloudPublish@1
     displayName: 'SonarCloud: Publish Quality Gate Result'
+    condition: and(succeeded(), ne(variables['Build.Reason'], 'PullRequest')) # Do not run for PullRequests
   
   - task: whitesource.ws-bolt.bolt.wss.WhiteSource Bolt@19
     displayName: 'WhiteSource Bolt'

examples/WireMock.Net.Client/Program.cs

@@ -22,6 +22,11 @@ namespace WireMock.Net.Client
             var settings1 = await api.GetSettingsAsync();
             Console.WriteLine($"settings1 = {JsonConvert.SerializeObject(settings1)}");
 
+            var settingsViaBuilder = new FluentBuilder.SettingsModelBuilder()
+                .WithGlobalProcessingDelay(1077)
+                .WithoutGlobalProcessingDelay()
+                .Build();
+
             settings1.GlobalProcessingDelay = 1077;
             api.PostSettingsAsync(settings1).Wait();
 

examples/WireMock.Net.Console.Net452.Classic/MainApp.cs

@@ -59,6 +59,7 @@ namespace WireMock.Net.ConsoleApplication
                 //},
                 PreWireMockMiddlewareInit = app => { System.Console.WriteLine($"PreWireMockMiddlewareInit : {app.GetType()}"); },
                 PostWireMockMiddlewareInit = app => { System.Console.WriteLine($"PostWireMockMiddlewareInit : {app.GetType()}"); },
+                AdditionalServiceRegistration = services => { System.Console.WriteLine($"AdditionalServiceRegistration : {services.GetType()}"); },
                 Logger = new WireMockConsoleLogger(),
 
                 HandlebarsRegistrationCallback = (handlebarsContext, fileSystemHandler) =>

examples/WireMock.Net.OpenApiParser.ConsoleApp/Run.cs

@@ -3,9 +3,11 @@ using System.Collections.Generic;
 using System.Linq;
 using WireMock.Admin.Mappings;
 using WireMock.Logging;
+using WireMock.Net.OpenApiParser.Extensions;
+using WireMock.Net.OpenApiParser.Settings;
+using WireMock.Net.OpenApiParser.Types;
 using WireMock.Server;
 using WireMock.Settings;
-using WireMock.Net.OpenApiParser.Extensions;
 
 namespace WireMock.Net.OpenApiParser.ConsoleApp
 {
@@ -23,13 +25,18 @@ namespace WireMock.Net.OpenApiParser.ConsoleApp
                 ReadStaticMappings = false,
                 WatchStaticMappings = false,
                 WatchStaticMappingsInSubdirectories = false,
-                Logger = new WireMockConsoleLogger(),
+                Logger = new WireMockConsoleLogger()
             });
             Console.WriteLine("WireMockServer listening at {0}", string.Join(",", server.Urls));
 
             server.SetBasicAuthentication("a", "b");
 
-            server.WithMappingFromOpenApiFile(path, out var diag);
+            var settings = new WireMockOpenApiParserSettings
+            {
+                PathPatternToUse = ExampleValueType.Wildcard
+            };
+
+            server.WithMappingFromOpenApiFile(path, settings, out var diag);
 
             Console.WriteLine("Press any key to stop the server");
             System.Console.ReadKey();

examples/WireMock.Net.StandAlone.Net461/packages.config

@@ -76,7 +76,7 @@
   <package id="System.Security.Cryptography.Primitives" version="4.3.0" targetFramework="net461" />
   <package id="System.Security.Cryptography.X509Certificates" version="4.3.0" targetFramework="net461" />
   <package id="System.Security.Principal.Windows" version="4.5.1" targetFramework="net461" />
-  <package id="System.Text.Encodings.Web" version="4.5.0" targetFramework="net461" />
+  <package id="System.Text.Encodings.Web" version="4.5.1" targetFramework="net461" />
   <package id="System.Threading.Tasks.Extensions" version="4.5.1" targetFramework="net461" />
   <package id="XPath2" version="1.1.0" targetFramework="net461" />
 </packages>

src/WireMock.Net.Abstractions/Admin/Mappings/BodyModel.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// Body Model
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class BodyModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Mappings/ClientIPModel.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// ClientIPModel
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class ClientIPModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Mappings/CookieModel.cs

@@ -5,6 +5,7 @@ namespace WireMock.Admin.Mappings
     /// <summary>
     /// Cookie Model
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class CookieModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Mappings/EncodingModel.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// EncodingModel
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class EncodingModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Mappings/FaultModel.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// Fault Model
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class FaultModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Mappings/HeaderModel.cs

@@ -5,6 +5,7 @@ namespace WireMock.Admin.Mappings
     /// <summary>
     /// Header Model
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class HeaderModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Mappings/MappingModel.cs

@@ -5,6 +5,7 @@ namespace WireMock.Admin.Mappings
     /// <summary>
     /// MappingModel
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class MappingModel
     {
         /// <summary>
@@ -57,5 +58,10 @@ namespace WireMock.Admin.Mappings
         /// The Webhook.
         /// </summary>
         public WebhookModel Webhook { get; set; }
+
+        /// <summary>
+        /// The Webhooks.
+        /// </summary>
+        public WebhookModel[] Webhooks { get; set; }
     }
 }

src/WireMock.Net.Abstractions/Admin/Mappings/MatcherModel.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// MatcherModel
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class MatcherModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Mappings/ParamModel.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// Param Model
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class ParamModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Mappings/PathModel.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// PathModel
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class PathModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Mappings/RequestModel.cs

@@ -5,6 +5,7 @@ namespace WireMock.Admin.Mappings
     /// <summary>
     /// RequestModel
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class RequestModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Mappings/ResponseModel.cs

@@ -5,6 +5,7 @@ namespace WireMock.Admin.Mappings
     /// <summary>
     /// ResponseModel
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class ResponseModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Mappings/StatusModel.cs

@@ -5,6 +5,7 @@ namespace WireMock.Admin.Mappings
     /// <summary>
     /// Status
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class StatusModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Mappings/UrlModel.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// UrlModel
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class UrlModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Mappings/WebProxyModel.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// WebProxy settings
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class WebProxyModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Mappings/WebhookModel.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// The Webhook
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class WebhookModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Mappings/WebhookRequestModel.cs

@@ -5,6 +5,7 @@ namespace WireMock.Admin.Mappings
     /// <summary>
     /// RequestModel
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class WebhookRequestModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Requests/LogEntryModel.cs

@@ -5,6 +5,7 @@ namespace WireMock.Admin.Requests
     /// <summary>
     /// Request Log Model
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class LogEntryModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Requests/LogRequestMatchModel.cs

@@ -5,6 +5,7 @@ namespace WireMock.Admin.Requests
     /// <summary>
     /// LogRequestMatchModel
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class LogRequestMatchModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Requests/LogRequestModel.cs

@@ -8,6 +8,7 @@ namespace WireMock.Admin.Requests
     /// <summary>
     /// RequestMessage Model
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class LogRequestModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Requests/LogResponseModel.cs

@@ -7,6 +7,7 @@ namespace WireMock.Admin.Requests
     /// <summary>
     /// Response MessageModel
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class LogResponseModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Scenarios/ScenarioStateModel.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// ScenarioStateModel
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class ScenarioStateModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/Admin/Settings/SettingsModel.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// Settings
     /// </summary>
+    [FluentBuilder.AutoGenerateBuilder]
     public class SettingsModel
     {
         /// <summary>

src/WireMock.Net.Abstractions/WireMock.Net.Abstractions.csproj

@@ -1,37 +1,46 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
-  <PropertyGroup>
-    <Description>Commonly used interfaces, models, enumerations and types.</Description>
-    <AssemblyTitle>WireMock.Net.Abstractions</AssemblyTitle>
-    <Authors>Stef Heyenrath</Authors>
-    <TargetFrameworks>net45;netstandard1.0;netstandard2.0;netstandard2.1</TargetFrameworks>
-    <GenerateDocumentationFile>true</GenerateDocumentationFile>
-    <AssemblyName>WireMock.Net.Abstractions</AssemblyName>
-    <PackageId>WireMock.Net.Abstractions</PackageId>
-    <PackageTags>wiremock;interfaces;models;classes;enumerations;types</PackageTags>
-    <RootNamespace>WireMock</RootNamespace>
-    <ProjectGuid>{B6269AAC-170A-4346-8B9A-579DED3D9A94}</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>
-  </PropertyGroup>
+    <PropertyGroup>
+        <Description>Commonly used interfaces, models, enumerations and types.</Description>
+        <AssemblyTitle>WireMock.Net.Abstractions</AssemblyTitle>
+        <Authors>Stef Heyenrath</Authors>
+        <TargetFrameworks>net45;netstandard1.0;netstandard2.0;netstandard2.1</TargetFrameworks>
 
-  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
-    <!--<PathMap>$(MSBuildProjectDirectory)=/</PathMap>-->
-    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-  </PropertyGroup>
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+        <NoWarn>$(NoWarn);1591;8603</NoWarn>
 
-  <ItemGroup>
-    <PackageReference Include="JetBrains.Annotations" Version="2020.1.0" PrivateAssets="All" />
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
-  </ItemGroup>
+        <AssemblyName>WireMock.Net.Abstractions</AssemblyName>
+        <PackageId>WireMock.Net.Abstractions</PackageId>
+        <PackageTags>wiremock;interfaces;models;classes;enumerations;types</PackageTags>
+        <RootNamespace>WireMock</RootNamespace>
+        <ProjectGuid>{B6269AAC-170A-4346-8B9A-579DED3D9A94}</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>
+    </PropertyGroup>
+
+    <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
+        <!--<PathMap>$(MSBuildProjectDirectory)=/</PathMap>-->
+        <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="JetBrains.Annotations" Version="2020.1.0" PrivateAssets="All" />
+        <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
+
+        <!-- See also https://mstack.nl/blog/20210801-source-generators -->
+        <PackageReference Include="FluentBuilder" Version="0.0.7">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+    </ItemGroup>
 
 </Project>

src/WireMock.Net.OpenApiParser/Extensions/WireMockServerExtensions.cs

@@ -1,12 +1,19 @@
-using System;
-using System.IO;
+using System.IO;
 using System.Linq;
+using System.Runtime.InteropServices.ComTypes;
+using JetBrains.Annotations;
 using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.Readers;
+using SharpYaml.Model;
+using Stef.Validation;
+using WireMock.Net.OpenApiParser.Settings;
 using WireMock.Server;
 
 namespace WireMock.Net.OpenApiParser.Extensions
 {
+    /// <summary>
+    /// Some extension methods for <see cref="IWireMockServer"/>.
+    /// </summary>
     public static class WireMockServerExtensions
     {
         /// <summary>
@@ -15,18 +22,26 @@ namespace WireMock.Net.OpenApiParser.Extensions
         /// <param name="server">The WireMockServer instance</param>
         /// <param name="path">Path containing OpenAPI file to parse and use the mappings.</param>
         /// <param name="diagnostic">Returns diagnostic object containing errors detected during parsing</param>
+        [PublicAPI]
         public static IWireMockServer WithMappingFromOpenApiFile(this IWireMockServer server, string path, out OpenApiDiagnostic diagnostic)
         {
-            if (server == null)
-            {
-                throw new ArgumentNullException(nameof(server));
-            }
-            if (string.IsNullOrEmpty(path))
-            {
-                throw new ArgumentNullException(nameof(path));
-            }
+            return WithMappingFromOpenApiFile(server, path, null, out diagnostic);
+        }
 
-            var mappings = new WireMockOpenApiParser().FromFile(path, out diagnostic);
+        /// <summary>
+        /// Register the mappings via an OpenAPI (swagger) V2 or V3 file.
+        /// </summary>
+        /// <param name="server">The WireMockServer instance</param>
+        /// <param name="path">Path containing OpenAPI file to parse and use the mappings.</param>
+        /// <param name="diagnostic">Returns diagnostic object containing errors detected during parsing</param>
+        /// <param name="settings">Additional settings</param>
+        [PublicAPI]
+        public static IWireMockServer WithMappingFromOpenApiFile(this IWireMockServer server, string path, WireMockOpenApiParserSettings settings, out OpenApiDiagnostic diagnostic)
+        {
+            Guard.NotNull(server, nameof(server));
+            Guard.NotNullOrEmpty(path, nameof(path));
+
+            var mappings = new WireMockOpenApiParser().FromFile(path, settings, out diagnostic);
 
             return server.WithMapping(mappings.ToArray());
         }
@@ -37,9 +52,27 @@ namespace WireMock.Net.OpenApiParser.Extensions
         /// <param name="server">The WireMockServer instance</param>
         /// <param name="stream">Stream containing OpenAPI description to parse and use the mappings.</param>
         /// <param name="diagnostic">Returns diagnostic object containing errors detected during parsing</param>
+        [PublicAPI]
         public static IWireMockServer WithMappingFromOpenApiStream(this IWireMockServer server, Stream stream, out OpenApiDiagnostic diagnostic)
         {
-            var mappings = new WireMockOpenApiParser().FromStream(stream, out diagnostic);
+            return WithMappingFromOpenApiStream(server, stream, null, out diagnostic);
+        }
+
+        /// <summary>
+        /// Register the mappings via an OpenAPI (swagger) V2 or V3 stream.
+        /// </summary>
+        /// <param name="server">The WireMockServer instance</param>
+        /// <param name="stream">Stream containing OpenAPI description to parse and use the mappings.</param>
+        /// <param name="settings">Additional settings</param>
+        /// <param name="diagnostic">Returns diagnostic object containing errors detected during parsing</param>
+        [PublicAPI]
+        public static IWireMockServer WithMappingFromOpenApiStream(this IWireMockServer server, Stream stream, WireMockOpenApiParserSettings settings, out OpenApiDiagnostic diagnostic)
+        {
+            Guard.NotNull(server, nameof(server));
+            Guard.NotNull(stream, nameof(stream));
+            Guard.NotNull(settings, nameof(settings));
+
+            var mappings = new WireMockOpenApiParser().FromStream(stream, settings, out diagnostic);
 
             return server.WithMapping(mappings.ToArray());
         }
@@ -49,9 +82,14 @@ namespace WireMock.Net.OpenApiParser.Extensions
         /// </summary>
         /// <param name="server">The WireMockServer instance</param>
         /// <param name="document">The OpenAPI document to use as mappings.</param>
-        public static IWireMockServer WithMappingFromOpenApiDocument(this IWireMockServer server, OpenApiDocument document)
+        /// <param name="settings">Additional settings [optional]</param>
+        [PublicAPI]
+        public static IWireMockServer WithMappingFromOpenApiDocument(this IWireMockServer server, OpenApiDocument document, WireMockOpenApiParserSettings settings = null)
         {
-            var mappings = new WireMockOpenApiParser().FromDocument(document);
+            Guard.NotNull(server, nameof(server));
+            Guard.NotNull(document, nameof(document));
+
+            var mappings = new WireMockOpenApiParser().FromDocument(document, settings);
 
             return server.WithMapping(mappings.ToArray());
         }

src/WireMock.Net.OpenApiParser/IWireMockOpenApiParser.cs

@@ -1,37 +1,57 @@
-using System.Collections.Generic;
-using System.IO;
-using Microsoft.OpenApi.Models;
-using Microsoft.OpenApi.Readers;
-using WireMock.Admin.Mappings;
-
-namespace WireMock.Net.OpenApiParser
-{
-    /// <summary>
-    /// Parse a OpenApi/Swagger/V2/V3 or Raml to WireMock MappingModels.
-    /// </summary>
-    public interface IWireMockOpenApiParser
-    {
-        /// <summary>
-        /// Generate <see cref="IEnumerable{MappingModel}"/> from an <seealso cref="OpenApiDocument"/>.
-        /// </summary>
-        /// <param name="document">The source OpenApiDocument</param>
-        /// <returns>MappingModel</returns>
-        IEnumerable<MappingModel> FromDocument(OpenApiDocument document);
-
-        /// <summary>
-        /// Generate <see cref="IEnumerable{MappingModel}"/> from a <seealso cref="Stream"/>.
-        /// </summary>
-        /// <param name="stream">The source stream</param>
-        /// <param name="diagnostic">OpenApiDiagnostic output</param>
-        /// <returns>MappingModel</returns>
-        IEnumerable<MappingModel> FromStream(Stream stream, out OpenApiDiagnostic diagnostic);
-
+using System.Collections.Generic;
+using System.IO;
+using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Readers;
+using WireMock.Admin.Mappings;
+using WireMock.Net.OpenApiParser.Settings;
+
+namespace WireMock.Net.OpenApiParser
+{
+    /// <summary>
+    /// Parse a OpenApi/Swagger/V2/V3 or Raml to WireMock MappingModels.
+    /// </summary>
+    public interface IWireMockOpenApiParser
+    {
         /// <summary>
         /// Generate <see cref="IEnumerable{MappingModel}"/> from a file-path.
         /// </summary>
         /// <param name="path">The path to read the OpenApi/Swagger/V2/V3 or Raml file.</param>
         /// <param name="diagnostic">OpenApiDiagnostic output</param>
-        /// <returns>MappingModel</returns>
-        IEnumerable<MappingModel> FromFile(string path, out OpenApiDiagnostic diagnostic);
-    }
+        /// <returns>MappingModel</returns>
+        IEnumerable<MappingModel> FromFile(string path, out OpenApiDiagnostic diagnostic);
+
+        /// <summary>
+        /// Generate <see cref="IEnumerable{MappingModel}"/> from a file-path.
+        /// </summary>
+        /// <param name="path">The path to read the OpenApi/Swagger/V2/V3 or Raml file.</param>
+        /// <param name="settings">Additional settings</param>
+        /// <param name="diagnostic">OpenApiDiagnostic output</param>
+        /// <returns>MappingModel</returns>
+        IEnumerable<MappingModel> FromFile(string path, WireMockOpenApiParserSettings settings, out OpenApiDiagnostic diagnostic);
+
+        /// <summary>
+        /// Generate <see cref="IEnumerable{MappingModel}"/> from an <seealso cref="OpenApiDocument"/>.
+        /// </summary>
+        /// <param name="document">The source OpenApiDocument</param>
+        /// <param name="settings">Additional settings [optional]</param>
+        /// <returns>MappingModel</returns>
+        IEnumerable<MappingModel> FromDocument(OpenApiDocument document, WireMockOpenApiParserSettings settings = null);
+
+        /// <summary>
+        /// Generate <see cref="IEnumerable{MappingModel}"/> from a <seealso cref="Stream"/>.
+        /// </summary>
+        /// <param name="stream">The source stream</param>
+        /// <param name="diagnostic">OpenApiDiagnostic output</param>
+        /// <returns>MappingModel</returns>
+        IEnumerable<MappingModel> FromStream(Stream stream, out OpenApiDiagnostic diagnostic);
+
+        /// <summary>
+        /// Generate <see cref="IEnumerable{MappingModel}"/> from a <seealso cref="Stream"/>.
+        /// </summary>
+        /// <param name="stream">The source stream</param>
+        /// <param name="settings">Additional settings</param>
+        /// <param name="diagnostic">OpenApiDiagnostic output</param>
+        /// <returns>MappingModel</returns>
+        IEnumerable<MappingModel> FromStream(Stream stream, WireMockOpenApiParserSettings settings, out OpenApiDiagnostic diagnostic);
+    }
 }

src/WireMock.Net.OpenApiParser/Mappers/OpenApiPathsMapper.cs

@@ -0,0 +1,276 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Microsoft.OpenApi;
+using Microsoft.OpenApi.Any;
+using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Writers;
+using Newtonsoft.Json.Linq;
+using WireMock.Admin.Mappings;
+using WireMock.Net.OpenApiParser.Extensions;
+using WireMock.Net.OpenApiParser.Settings;
+using WireMock.Net.OpenApiParser.Types;
+using WireMock.Net.OpenApiParser.Utils;
+
+namespace WireMock.Net.OpenApiParser.Mappers
+{
+    internal class OpenApiPathsMapper
+    {
+        private readonly WireMockOpenApiParserSettings _settings;
+        private readonly ExampleValueGenerator _exampleValueGenerator;
+
+        public OpenApiPathsMapper(WireMockOpenApiParserSettings settings)
+        {
+            _settings = settings ?? throw new ArgumentNullException(nameof(settings));
+            _exampleValueGenerator = new ExampleValueGenerator(settings);
+        }
+
+        public IEnumerable<MappingModel> ToMappingModels(OpenApiPaths paths)
+        {
+            return paths.Select(p => MapPath(p.Key, p.Value)).SelectMany(x => x);
+        }
+
+        private IEnumerable<MappingModel> MapPaths(OpenApiPaths paths)
+        {
+            return paths.Select(p => MapPath(p.Key, p.Value)).SelectMany(x => x);
+        }
+
+        private IEnumerable<MappingModel> MapPath(string path, OpenApiPathItem pathItem)
+        {
+            return pathItem.Operations.Select(o => MapOperationToMappingModel(path, o.Key.ToString().ToUpperInvariant(), o.Value));
+        }
+
+        private MappingModel MapOperationToMappingModel(string path, string httpMethod, OpenApiOperation operation)
+        {
+            var queryParameters = operation.Parameters.Where(p => p.In == ParameterLocation.Query);
+            var pathParameters = operation.Parameters.Where(p => p.In == ParameterLocation.Path);
+            var response = operation.Responses.FirstOrDefault();
+
+            TryGetContent(response.Value?.Content, out OpenApiMediaType responseContent, out string responseContentType);
+            var responseSchema = response.Value?.Content?.FirstOrDefault().Value?.Schema;
+            var responseExample = responseContent?.Example;
+
+            var body = responseExample != null ? MapOpenApiAnyToJToken(responseExample) : MapSchemaToObject(responseSchema);
+
+            if (int.TryParse(response.Key, out var httpStatusCode))
+            {
+                httpStatusCode = 200;
+            }
+
+            return new MappingModel
+            {
+                Guid = Guid.NewGuid(),
+                Request = new RequestModel
+                {
+                    Methods = new[] { httpMethod },
+                    Path = MapPathWithParameters(path, pathParameters),
+                    Params = MapQueryParameters(queryParameters)
+                },
+                Response = new ResponseModel
+                {
+                    StatusCode = httpStatusCode,
+                    Headers = MapHeaders(responseContentType, response.Value?.Headers),
+                    BodyAsJson = body
+                }
+            };
+        }
+
+        private bool TryGetContent(IDictionary<string, OpenApiMediaType> contents, out OpenApiMediaType openApiMediaType, out string contentType)
+        {
+            openApiMediaType = null;
+            contentType = null;
+
+            if (contents == null || contents.Values.Count == 0)
+            {
+                return false;
+            }
+
+            if (contents.TryGetValue("application/json", out var content))
+            {
+                openApiMediaType = content;
+                contentType = "application/json";
+            }
+            else
+            {
+                var first = contents.FirstOrDefault();
+                openApiMediaType = first.Value;
+                contentType = first.Key;
+            }
+
+            return true;
+        }
+
+        private object MapSchemaToObject(OpenApiSchema schema, string name = null)
+        {
+            if (schema == null)
+            {
+                return null;
+            }
+
+            switch (schema.GetSchemaType())
+            {
+                case SchemaType.Array:
+                    var jArray = new JArray();
+                    for (int i = 0; i < _settings.NumberOfArrayItems; i++)
+                    {
+                        if (schema.Items.Properties.Count > 0)
+                        {
+                            var arrayItem = new JObject();
+                            foreach (var property in schema.Items.Properties)
+                            {
+                                var objectValue = MapSchemaToObject(property.Value, property.Key);
+                                if (objectValue is JProperty jp)
+                                {
+                                    arrayItem.Add(jp);
+                                }
+                                else
+                                {
+                                    arrayItem.Add(new JProperty(property.Key, objectValue));
+                                }
+                            }
+
+                            jArray.Add(arrayItem);
+                        }
+                        else
+                        {
+                            jArray.Add(MapSchemaToObject(schema.Items, name));
+                        }
+                    }
+
+                    return jArray;
+
+                case SchemaType.Boolean:
+                case SchemaType.Integer:
+                case SchemaType.Number:
+                case SchemaType.String:
+                    return _exampleValueGenerator.GetExampleValue(schema);
+
+                case SchemaType.Object:
+                    var propertyAsJObject = new JObject();
+                    foreach (var schemaProperty in schema.Properties)
+                    {
+                        string propertyName = schemaProperty.Key;
+                        var openApiSchema = schemaProperty.Value;
+                        if (openApiSchema.GetSchemaType() == SchemaType.Object)
+                        {
+                            var mapped = MapSchemaToObject(schemaProperty.Value, schemaProperty.Key);
+                            if (mapped is JProperty jp)
+                            {
+                                propertyAsJObject.Add(jp);
+                            }
+                        }
+                        else
+                        {
+                            bool propertyIsNullable = openApiSchema.Nullable || (openApiSchema.TryGetXNullable(out bool x) && x);
+
+                            propertyAsJObject.Add(new JProperty(propertyName, _exampleValueGenerator.GetExampleValue(openApiSchema)));
+                        }
+                    }
+
+                    return name != null ? new JProperty(name, propertyAsJObject) : (JToken)propertyAsJObject;
+
+                default:
+                    return null;
+            }
+        }
+
+        private string MapPathWithParameters(string path, IEnumerable<OpenApiParameter> parameters)
+        {
+            if (parameters == null)
+            {
+                return path;
+            }
+
+            string newPath = path;
+            foreach (var parameter in parameters)
+            {
+                newPath = newPath.Replace($"{{{parameter.Name}}}", GetExampleValue(parameter.Schema, _settings.PathPatternToUse));
+            }
+
+            return newPath;
+        }
+
+        private JToken MapOpenApiAnyToJToken(IOpenApiAny any)
+        {
+            if (any == null)
+            {
+                return null;
+            }
+
+            using var outputString = new StringWriter();
+            var writer = new OpenApiJsonWriter(outputString);
+            any.Write(writer, OpenApiSpecVersion.OpenApi3_0);
+
+            return JObject.Parse(outputString.ToString());
+        }
+
+        private IDictionary<string, object> MapHeaders(string responseContentType, IDictionary<string, OpenApiHeader> headers)
+        {
+            var mappedHeaders = headers.ToDictionary(
+                item => item.Key,
+                item => GetExampleValue(null, _settings.HeaderPatternToUse) as object
+            );
+
+            if (!string.IsNullOrEmpty(responseContentType))
+            {
+                if (!mappedHeaders.ContainsKey("Content-Type"))
+                {
+                    mappedHeaders.Add("Content-Type", responseContentType);
+                }
+                else
+                {
+                    mappedHeaders["Content-Type"] = responseContentType;
+                }
+            }
+
+            return mappedHeaders.Keys.Any() ? mappedHeaders : null;
+        }
+
+        private IList<ParamModel> MapQueryParameters(IEnumerable<OpenApiParameter> queryParameters)
+        {
+            var list = queryParameters
+                .Select(qp => new ParamModel
+                {
+                    Name = qp.Name,
+                    Matchers = new[]
+                    {
+                        new MatcherModel
+                        {
+                            Name = "ExactMatcher",
+                            Pattern = GetDefaultValueAsStringForSchemaType(qp.Schema)
+                        }
+                    }
+                })
+                .ToList();
+
+            return list.Any() ? list : null;
+        }
+
+        private string GetDefaultValueAsStringForSchemaType(OpenApiSchema schema)
+        {
+            var value = _exampleValueGenerator.GetExampleValue(schema);
+
+            switch (value)
+            {
+                case string valueAsString:
+                    return valueAsString;
+
+                default:
+                    return value.ToString();
+            }
+        }
+
+        private string GetExampleValue(OpenApiSchema schema, ExampleValueType type)
+        {
+            switch (type)
+            {
+                case ExampleValueType.Value:
+                    return GetDefaultValueAsStringForSchemaType(schema);
+
+                default:
+                    return "*";
+            }
+        }
+    }
+}

src/WireMock.Net.OpenApiParser/Settings/WireMockOpenApiParserExampleValues.cs

@@ -0,0 +1,30 @@
+using System;
+
+namespace WireMock.Net.OpenApiParser.Settings
+{
+    /// <summary>
+    /// A class defining the example values to use for the different types.
+    /// </summary>
+    public class WireMockOpenApiParserExampleValues
+    {
+#pragma warning disable 1591
+        public bool Boolean { get; set; } = true;
+
+        public int Integer { get; set; } = 42;
+
+        public float Float { get; set; } = 4.2f;
+
+        public double Double { get; set; } = 4.2d;
+
+        public Func<DateTime> Date { get; set; } = () => System.DateTime.UtcNow.Date;
+
+        public Func<DateTime> DateTime { get; set; } = () => System.DateTime.UtcNow;
+
+        public byte[] Bytes { get; set; } = { 48, 49, 50 };
+
+        public object Object { get; set; } = "example-object";
+
+        public string String { get; set; } = "example-string";
+#pragma warning restore 1591
+    }
+}

src/WireMock.Net.OpenApiParser/Settings/WireMockOpenApiParserSettings.cs

@@ -0,0 +1,30 @@
+using WireMock.Net.OpenApiParser.Types;
+
+namespace WireMock.Net.OpenApiParser.Settings
+{
+    /// <summary>
+    /// The WireMockOpenApiParser Settings
+    /// </summary>
+    public class WireMockOpenApiParserSettings
+    {
+        /// <summary>
+        /// The number of array items to generate (default is 3).
+        /// </summary>
+        public int NumberOfArrayItems { get; set; } = 3;
+
+        /// <summary>
+        /// The example value type to use when generating a Path
+        /// </summary>
+        public ExampleValueType PathPatternToUse { get; set; } = ExampleValueType.Value;
+
+        /// <summary>
+        /// The example value type to use when generating a Header
+        /// </summary>
+        public ExampleValueType HeaderPatternToUse { get; set; } = ExampleValueType.Value;
+
+        /// <summary>
+        /// The example values to use
+        /// </summary>
+        public WireMockOpenApiParserExampleValues ExampleValues { get; } = new WireMockOpenApiParserExampleValues();
+    }
+}

src/WireMock.Net.OpenApiParser/Types/ExampleValueType.cs

@@ -0,0 +1,18 @@
+namespace WireMock.Net.OpenApiParser.Types
+{
+    /// <summary>
+    /// The example value to use
+    /// </summary>
+    public enum ExampleValueType
+    {
+        /// <summary>
+        /// Use a generated example value based on the SchemaType (default).
+        /// </summary>
+        Value,
+
+        /// <summary>
+        /// Just use a Wildcard (*) character.
+        /// </summary>
+        Wildcard
+    }
+}

src/WireMock.Net.OpenApiParser/Utils/ExampleValueGenerator.cs

@@ -1,49 +1,57 @@
 using System;
 using Microsoft.OpenApi.Models;
 using WireMock.Net.OpenApiParser.Extensions;
+using WireMock.Net.OpenApiParser.Settings;
 using WireMock.Net.OpenApiParser.Types;
 
 namespace WireMock.Net.OpenApiParser.Utils
 {
-    internal static class ExampleValueGenerator
+    internal class ExampleValueGenerator
     {
-        public static object GetExampleValue(OpenApiSchema schema)
+        private readonly WireMockOpenApiParserSettings _settings;
+
+        public ExampleValueGenerator(WireMockOpenApiParserSettings settings)
+        {
+            _settings = settings ?? throw new ArgumentNullException(nameof(settings));
+        }
+
+        public object GetExampleValue(OpenApiSchema schema)
         {
             switch (schema?.GetSchemaType())
             {
                 case SchemaType.Boolean:
-                    return true;
+                    return _settings.ExampleValues.Boolean;
 
                 case SchemaType.Integer:
-                    return 42;
+                    return _settings.ExampleValues.Integer;
 
                 case SchemaType.Number:
                     switch (schema?.GetSchemaFormat())
                     {
                         case SchemaFormat.Float:
-                            return 4.2f;
+                            return _settings.ExampleValues.Float;
 
                         default:
-                            return 4.2d;
+                            return _settings.ExampleValues.Double;
                     }
 
                 default:
                     switch (schema?.GetSchemaFormat())
                     {
                         case SchemaFormat.Date:
-                            return DateTimeUtils.ToRfc3339Date(DateTime.UtcNow);
+                            return DateTimeUtils.ToRfc3339Date(_settings.ExampleValues.Date());
 
                         case SchemaFormat.DateTime:
-                            return DateTimeUtils.ToRfc3339DateTime(DateTime.UtcNow);
+                            return DateTimeUtils.ToRfc3339DateTime(_settings.ExampleValues.DateTime());
 
                         case SchemaFormat.Byte:
-                            return new byte[] { 48, 49, 50 };
+                            return _settings.ExampleValues.Bytes;
 
                         case SchemaFormat.Binary:
-                            return "example-object";
+                            return _settings.ExampleValues.Object;
 
                         default:
-                            return "example-string";
+                            return _settings.ExampleValues.String;
                     }
             }
         }

src/WireMock.Net.OpenApiParser/WireMock.Net.OpenApiParser.csproj

@@ -12,6 +12,7 @@
 		<AssemblyOriginatorKeyFile>../WireMock.Net/WireMock.Net.snk</AssemblyOriginatorKeyFile>
 		<PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
+    <LangVersion>8.0</LangVersion>
 	</PropertyGroup>
 
 	<PropertyGroup Condition="'$(Configuration)' == 'Release'">
@@ -24,14 +25,11 @@
 		<PackageReference Include="RamlToOpenApiConverter" Version="0.1.1" />
 		<PackageReference Include="JetBrains.Annotations" Version="2020.1.0" PrivateAssets="All" />
 		<PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
+		<PackageReference Include="Stef.Validation" Version="0.0.3" />
 	</ItemGroup>
 
 	<ItemGroup>
 		<ProjectReference Include="..\WireMock.Net.Abstractions\WireMock.Net.Abstractions.csproj" />
 	</ItemGroup>
 
-	<ItemGroup>
-		<Folder Include="Options\" />
-	</ItemGroup>
-
 </Project>

src/WireMock.Net.OpenApiParser/WireMockOpenApiParser.cs

@@ -1,34 +1,33 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using JetBrains.Annotations;
-using Microsoft.OpenApi;
-using Microsoft.OpenApi.Any;
 using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.Readers;
-using Microsoft.OpenApi.Writers;
-using Newtonsoft.Json.Linq;
 using RamlToOpenApiConverter;
 using WireMock.Admin.Mappings;
-using WireMock.Net.OpenApiParser.Extensions;
-using WireMock.Net.OpenApiParser.Types;
-using WireMock.Net.OpenApiParser.Utils;
+using WireMock.Net.OpenApiParser.Mappers;
+using WireMock.Net.OpenApiParser.Settings;
 
 namespace WireMock.Net.OpenApiParser
 {
     /// <summary>
-    /// Parse a OpenApi/Swagger/V2/V3 or Raml to WireMock MappingModels.
+    /// Parse a OpenApi/Swagger/V2/V3 or Raml to WireMock.Net MappingModels.
     /// </summary>
     public class WireMockOpenApiParser : IWireMockOpenApiParser
     {
-        private const int ArrayItems = 3;
-
         private readonly OpenApiStreamReader _reader = new OpenApiStreamReader();
 
-        /// <inheritdoc cref="IWireMockOpenApiParser.FromFile" />
+        /// <inheritdoc cref="IWireMockOpenApiParser.FromFile(string, out OpenApiDiagnostic)" />
         [PublicAPI]
         public IEnumerable<MappingModel> FromFile(string path, out OpenApiDiagnostic diagnostic)
+        {
+            return FromFile(path, new WireMockOpenApiParserSettings(), out diagnostic);
+        }
+
+        /// <inheritdoc cref="IWireMockOpenApiParser.FromFile(string, WireMockOpenApiParserSettings, out OpenApiDiagnostic)" />
+        [PublicAPI]
+        public IEnumerable<MappingModel> FromFile(string path, WireMockOpenApiParserSettings settings, out OpenApiDiagnostic diagnostic)
         {
             OpenApiDocument document;
             if (Path.GetExtension(path).EndsWith("raml", StringComparison.OrdinalIgnoreCase))
@@ -42,248 +41,28 @@ namespace WireMock.Net.OpenApiParser
                 document = reader.Read(File.OpenRead(path), out diagnostic);
             }
 
-            return FromDocument(document);
+            return FromDocument(document, settings);
         }
 
-        /// <inheritdoc cref="IWireMockOpenApiParser.FromStream" />
+        /// <inheritdoc cref="IWireMockOpenApiParser.FromStream(Stream, out OpenApiDiagnostic)" />
         [PublicAPI]
         public IEnumerable<MappingModel> FromStream(Stream stream, out OpenApiDiagnostic diagnostic)
         {
             return FromDocument(_reader.Read(stream, out diagnostic));
         }
 
-        /// <inheritdoc cref="IWireMockOpenApiParser.FromDocument" />
+        /// <inheritdoc cref="IWireMockOpenApiParser.FromStream(Stream, WireMockOpenApiParserSettings, out OpenApiDiagnostic)" />
         [PublicAPI]
-        public IEnumerable<MappingModel> FromDocument(OpenApiDocument openApiDocument)
+        public IEnumerable<MappingModel> FromStream(Stream stream, WireMockOpenApiParserSettings settings, out OpenApiDiagnostic diagnostic)
         {
-            return MapPaths(openApiDocument.Paths);
+            return FromDocument(_reader.Read(stream, out diagnostic), settings);
         }
 
-        private static IEnumerable<MappingModel> MapPaths(OpenApiPaths paths)
+        /// <inheritdoc cref="IWireMockOpenApiParser.FromDocument(OpenApiDocument, WireMockOpenApiParserSettings)" />
+        [PublicAPI]
+        public IEnumerable<MappingModel> FromDocument(OpenApiDocument openApiDocument, WireMockOpenApiParserSettings settings = null)
         {
-            return paths.Select(p => MapPath(p.Key, p.Value)).SelectMany(x => x);
-        }
-
-        private static IEnumerable<MappingModel> MapPath(string path, OpenApiPathItem pathItem)
-        {
-            return pathItem.Operations.Select(o => MapOperationToMappingModel(path, o.Key.ToString().ToUpperInvariant(), o.Value));
-        }
-
-        private static MappingModel MapOperationToMappingModel(string path, string httpMethod, OpenApiOperation operation)
-        {
-            var queryParameters = operation.Parameters.Where(p => p.In == ParameterLocation.Query);
-            var pathParameters = operation.Parameters.Where(p => p.In == ParameterLocation.Path);
-            var response = operation.Responses.FirstOrDefault();
-            TryGetContent(response.Value?.Content, out OpenApiMediaType responseContent, out string responseContentType);
-            var responseSchema = response.Value?.Content?.FirstOrDefault().Value?.Schema;
-            var responseExample = responseContent?.Example;
-
-            var body = responseExample != null ? MapOpenApiAnyToJToken(responseExample) : MapSchemaToObject(responseSchema);
-
-            if (int.TryParse(response.Key, out var httpStatusCode))
-            {
-                httpStatusCode = 200;
-            }
-
-            return new MappingModel
-            {
-                Guid = Guid.NewGuid(),
-                Request = new RequestModel
-                {
-                    Methods = new[] { httpMethod },
-                    Path = MapPathWithParameters(path, pathParameters),
-                    Params = MapQueryParameters(queryParameters)
-                },
-                Response = new ResponseModel
-                {
-                    StatusCode = httpStatusCode,
-                    Headers = MapHeaders(responseContentType, response.Value?.Headers),
-                    BodyAsJson = body
-                }
-            };
-        }
-
-        private static bool TryGetContent(IDictionary<string, OpenApiMediaType> contents, out OpenApiMediaType openApiMediaType, out string contentType)
-        {
-            openApiMediaType = null;
-            contentType = null;
-
-            if (contents == null || contents.Values.Count == 0)
-            {
-                return false;
-            }
-
-            if (contents.TryGetValue("application/json", out var content))
-            {
-                openApiMediaType = content;
-                contentType = "application/json";
-            }
-            else
-            {
-                var first = contents.FirstOrDefault();
-                openApiMediaType = first.Value;
-                contentType = first.Key;
-            }
-
-            return true;
-        }
-
-        private static object MapSchemaToObject(OpenApiSchema schema, string name = null)
-        {
-            if (schema == null)
-            {
-                return null;
-            }
-
-            switch (schema.GetSchemaType())
-            {
-                case SchemaType.Array:
-                    var jArray = new JArray();
-                    for (int i = 0; i < ArrayItems; i++)
-                    {
-                        if (schema.Items.Properties.Count > 0)
-                        {
-                            var arrayItem = new JObject();
-                            foreach (var property in schema.Items.Properties)
-                            {
-                                var objectValue = MapSchemaToObject(property.Value, property.Key);
-                                if (objectValue is JProperty jp)
-                                {
-                                    arrayItem.Add(jp);
-                                }
-                                else
-                                {
-                                    arrayItem.Add(new JProperty(property.Key, objectValue));
-                                }
-                            }
-
-                            jArray.Add(arrayItem);
-                        }
-                        else
-                        {
-                            jArray.Add(MapSchemaToObject(schema.Items, name));
-                        }
-                    }
-
-                    return jArray;
-
-                case SchemaType.Boolean:
-                case SchemaType.Integer:
-                case SchemaType.Number:
-                case SchemaType.String:
-                    return ExampleValueGenerator.GetExampleValue(schema);
-
-                case SchemaType.Object:
-                    var propertyAsJObject = new JObject();
-                    foreach (var schemaProperty in schema.Properties)
-                    {
-                        string propertyName = schemaProperty.Key;
-                        var openApiSchema = schemaProperty.Value;
-                        if (openApiSchema.GetSchemaType() == SchemaType.Object)
-                        {
-                            var mapped = MapSchemaToObject(schemaProperty.Value, schemaProperty.Key);
-                            if (mapped is JProperty jp)
-                            {
-                                propertyAsJObject.Add(jp);
-                            }
-                        }
-                        else
-                        {
-                            bool propertyIsNullable = openApiSchema.Nullable || (openApiSchema.TryGetXNullable(out bool x) && x);
-
-                            propertyAsJObject.Add(new JProperty(propertyName, ExampleValueGenerator.GetExampleValue(openApiSchema)));
-                        }
-                    }
-
-                    return name != null ? new JProperty(name, propertyAsJObject) : (JToken)propertyAsJObject;
-
-                default:
-                    return null;
-            }
-        }
-
-        private static string MapPathWithParameters(string path, IEnumerable<OpenApiParameter> parameters)
-        {
-            if (parameters == null)
-            {
-                return path;
-            }
-
-            string newPath = path;
-            foreach (var parameter in parameters)
-            {
-                newPath = newPath.Replace($"{{{parameter.Name}}}", ExampleValueGenerator.GetExampleValue(parameter.Schema).ToString());
-            }
-
-            return newPath;
-        }
-
-        private static JToken MapOpenApiAnyToJToken(IOpenApiAny any)
-        {
-            if (any == null)
-            {
-                return null;
-            }
-
-            using (var outputString = new StringWriter())
-            {
-                var writer = new OpenApiJsonWriter(outputString);
-                any.Write(writer, OpenApiSpecVersion.OpenApi3_0);
-
-                return JObject.Parse(outputString.ToString());
-            }
-        }
-
-        private static IDictionary<string, object> MapHeaders(string responseContentType, IDictionary<string, OpenApiHeader> headers)
-        {
-            var mappedHeaders = headers.ToDictionary(item => item.Key, item => ExampleValueGenerator.GetExampleValue(null));
-            if (!string.IsNullOrEmpty(responseContentType))
-            {
-                if (!mappedHeaders.ContainsKey("Content-Type"))
-                {
-                    mappedHeaders.Add("Content-Type", responseContentType);
-                }
-                else
-                {
-                    mappedHeaders["Content-Type"] = responseContentType;
-                }
-            }
-
-            return mappedHeaders.Keys.Any() ? mappedHeaders : null;
-        }
-
-        private static IList<ParamModel> MapQueryParameters(IEnumerable<OpenApiParameter> queryParameters)
-        {
-            var list = queryParameters
-                .Select(qp => new ParamModel
-                {
-                    Name = qp.Name,
-                    Matchers = new[]
-                    {
-                        new MatcherModel
-                        {
-                            Name = "ExactMatcher",
-                            Pattern = GetDefaultValueAsStringForSchemaType(qp.Schema)
-                        }
-                    }
-                })
-                .ToList();
-
-            return list.Any() ? list : null;
-        }
-
-        private static string GetDefaultValueAsStringForSchemaType(OpenApiSchema schema)
-        {
-            var value = ExampleValueGenerator.GetExampleValue(schema);
-
-            switch (value)
-            {
-                case string valueAsString:
-                    return valueAsString;
-
-                default:
-                    return value.ToString();
-            }
+            return new OpenApiPathsMapper(settings).ToMappingModels(openApiDocument.Paths);
         }
     }
 }

src/WireMock.Net/IMapping.cs

@@ -95,9 +95,9 @@ namespace WireMock
         bool LogMapping { get; }
 
         /// <summary>
-        /// The Webhook.
+        /// The Webhooks.
         /// </summary>
-        IWebhook Webhook { get; }
+        IWebhook[] Webhooks { get; }
 
         /// <summary>
         /// ProvideResponseAsync

src/WireMock.Net/Mapping.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Threading.Tasks;
 using JetBrains.Annotations;
-using WireMock.Admin.Mappings;
 using WireMock.Matchers.Request;
 using WireMock.Models;
 using WireMock.ResponseProviders;
@@ -56,8 +55,8 @@ namespace WireMock
         /// <inheritdoc cref="IMapping.LogMapping" />
         public bool LogMapping => !(Provider is DynamicResponseProvider || Provider is DynamicAsyncResponseProvider);
 
-        /// <inheritdoc cref="IMapping.Webhook" />
-        public IWebhook Webhook { get; }
+        /// <inheritdoc cref="IMapping.Webhooks" />
+        public IWebhook[] Webhooks { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Mapping"/> class.
@@ -73,7 +72,7 @@ namespace WireMock
         /// <param name="executionConditionState">State in which the current mapping can occur. [Optional]</param>
         /// <param name="nextState">The next state which will occur after the current mapping execution. [Optional]</param>
         /// <param name="stateTimes">Only when the current state is executed this number, the next state which will occur. [Optional]</param>
-        /// <param name="webhook">The Webhook. [Optional]</param>
+        /// <param name="webhooks">The Webhooks. [Optional]</param>
         public Mapping(
             Guid guid,
             [CanBeNull] string title,
@@ -86,7 +85,7 @@ namespace WireMock
             [CanBeNull] string executionConditionState,
             [CanBeNull] string nextState,
             [CanBeNull] int? stateTimes,
-            [CanBeNull] IWebhook webhook)
+            [CanBeNull] IWebhook[] webhooks)
         {
             Guid = guid;
             Title = title;
@@ -99,7 +98,7 @@ namespace WireMock
             ExecutionConditionState = executionConditionState;
             NextState = nextState;
             StateTimes = stateTimes;
-            Webhook = webhook;
+            Webhooks = webhooks;
         }
 
         /// <inheritdoc cref="IMapping.ProvideResponseAsync" />

src/WireMock.Net/Matchers/IValueMatcher.cs

@@ -1,15 +1,15 @@
-namespace WireMock.Matchers
-{
-    /// <summary>
-    /// IValueMatcher
-    /// </summary>
-    /// <seealso cref="IObjectMatcher" />
-    public interface IValueMatcher: IObjectMatcher
-    {
-        /// <summary>
-        /// Gets the value (can be a string or an object).
-        /// </summary>
-        /// <returns>Value</returns>
-        object Value { get; }
-    }
+namespace WireMock.Matchers
+{
+    /// <summary>
+    /// IValueMatcher
+    /// </summary>
+    /// <seealso cref="IObjectMatcher" />
+    public interface IValueMatcher : IObjectMatcher
+    {
+        /// <summary>
+        /// Gets the value (can be a string or an object).
+        /// </summary>
+        /// <returns>Value</returns>
+        object Value { get; }
+    }
 }

src/WireMock.Net/Matchers/NotNullOrEmptyMatcher.cs

@@ -0,0 +1,52 @@
+using System.Linq;
+
+namespace WireMock.Matchers
+{
+    /// <summary>
+    /// NotNullOrEmptyMatcher
+    /// </summary>
+    /// <seealso cref="IObjectMatcher" />
+    public class NotNullOrEmptyMatcher : IObjectMatcher
+    {
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public string Name => "NotNullOrEmptyMatcher";
+
+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        public MatchBehaviour MatchBehaviour { get; }
+
+        /// <inheritdoc cref="IMatcher.ThrowException"/>
+        public bool ThrowException { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NotNullOrEmptyMatcher"/> class.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        public NotNullOrEmptyMatcher(MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
+        {
+            MatchBehaviour = matchBehaviour;
+        }
+
+        /// <inheritdoc cref="IObjectMatcher.IsMatch"/>
+        public double IsMatch(object input)
+        {
+            bool match;
+
+            switch (input)
+            {
+                case string @string:
+                    match = !string.IsNullOrEmpty(@string);
+                    break;
+
+                case byte[] bytes:
+                    match = bytes != null && bytes.Any();
+                    break;
+
+                default:
+                    match = input != null;
+                    break;
+            }
+
+            return MatchBehaviourHelper.Convert(MatchBehaviour, MatchScores.ToScore(match));
+        }
+    }
+}

src/WireMock.Net/Matchers/RegexMatcher.cs

@@ -1,113 +1,113 @@
-using System;
-using System.Linq;
-using System.Text.RegularExpressions;
-using JetBrains.Annotations;
-using WireMock.Validation;
-
-namespace WireMock.Matchers
-{
-    /// <summary>
-    /// Regular Expression Matcher
-    /// </summary>
-    /// <inheritdoc cref="IStringMatcher"/>
-    /// <inheritdoc cref="IIgnoreCaseMatcher"/>
-    public class RegexMatcher : IStringMatcher, IIgnoreCaseMatcher
-    {
-        private readonly string[] _patterns;
-        private readonly Regex[] _expressions;
-
-        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
-        public MatchBehaviour MatchBehaviour { get; }
-
-        /// <inheritdoc cref="IMatcher.ThrowException"/>
-        public bool ThrowException { get; }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="RegexMatcher"/> class.
-        /// </summary>
-        /// <param name="pattern">The pattern.</param>
-        /// <param name="ignoreCase">Ignore the case from the pattern.</param>
-        public RegexMatcher([NotNull, RegexPattern] string pattern, bool ignoreCase = false) : this(new[] { pattern }, ignoreCase)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="RegexMatcher"/> class.
-        /// </summary>
-        /// <param name="matchBehaviour">The match behaviour.</param>
-        /// <param name="pattern">The pattern.</param>
-        /// <param name="ignoreCase">Ignore the case from the pattern.</param>
-        public RegexMatcher(MatchBehaviour matchBehaviour, [NotNull, RegexPattern] string pattern, bool ignoreCase = false) : this(matchBehaviour, new[] { pattern }, ignoreCase)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="RegexMatcher"/> class.
-        /// </summary>
-        /// <param name="patterns">The patterns.</param>
-        /// <param name="ignoreCase">Ignore the case from the pattern.</param>
-        public RegexMatcher([NotNull, RegexPattern] string[] patterns, bool ignoreCase = false) : this(MatchBehaviour.AcceptOnMatch, patterns, ignoreCase)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="RegexMatcher"/> class.
-        /// </summary>
-        /// <param name="matchBehaviour">The match behaviour.</param>
-        /// <param name="patterns">The patterns.</param>
-        /// <param name="ignoreCase">Ignore the case from the pattern.</param>
-        /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-        public RegexMatcher(MatchBehaviour matchBehaviour, [NotNull, RegexPattern] string[] patterns, bool ignoreCase = false, bool throwException = false)
-        {
-            Check.NotNull(patterns, nameof(patterns));
-
-            _patterns = patterns;
-            IgnoreCase = ignoreCase;
-            MatchBehaviour = matchBehaviour;
-            ThrowException = throwException;
-
-            RegexOptions options = RegexOptions.Compiled | RegexOptions.Multiline;
-
-            if (ignoreCase)
-            {
-                options |= RegexOptions.IgnoreCase;
-            }
-
-            _expressions = patterns.Select(p => new Regex(p, options)).ToArray();
-        }
-
-        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
-        public virtual double IsMatch(string input)
-        {
-            double match = MatchScores.Mismatch;
-            if (input != null)
-            {
-                try
-                {
-                    match = MatchScores.ToScore(_expressions.Select(e => e.IsMatch(input)));
-                }
-                catch (Exception)
-                {
-                    if (ThrowException)
-                    {
-                        throw;
-                    }
-                }
+using System;
+using System.Linq;
+using System.Text.RegularExpressions;
+using JetBrains.Annotations;
+using WireMock.Validation;
+
+namespace WireMock.Matchers
+{
+    /// <summary>
+    /// Regular Expression Matcher
+    /// </summary>
+    /// <inheritdoc cref="IStringMatcher"/>
+    /// <inheritdoc cref="IIgnoreCaseMatcher"/>
+    public class RegexMatcher : IStringMatcher, IIgnoreCaseMatcher
+    {
+        private readonly string[] _patterns;
+        private readonly Regex[] _expressions;
+
+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        public MatchBehaviour MatchBehaviour { get; }
+
+        /// <inheritdoc cref="IMatcher.ThrowException"/>
+        public bool ThrowException { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RegexMatcher"/> class.
+        /// </summary>
+        /// <param name="pattern">The pattern.</param>
+        /// <param name="ignoreCase">Ignore the case from the pattern.</param>
+        public RegexMatcher([NotNull, RegexPattern] string pattern, bool ignoreCase = false) : this(new[] { pattern }, ignoreCase)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RegexMatcher"/> class.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="pattern">The pattern.</param>
+        /// <param name="ignoreCase">Ignore the case from the pattern.</param>
+        public RegexMatcher(MatchBehaviour matchBehaviour, [NotNull, RegexPattern] string pattern, bool ignoreCase = false) : this(matchBehaviour, new[] { pattern }, ignoreCase)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RegexMatcher"/> class.
+        /// </summary>
+        /// <param name="patterns">The patterns.</param>
+        /// <param name="ignoreCase">Ignore the case from the pattern.</param>
+        public RegexMatcher([NotNull, RegexPattern] string[] patterns, bool ignoreCase = false) : this(MatchBehaviour.AcceptOnMatch, patterns, ignoreCase)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RegexMatcher"/> class.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="patterns">The patterns.</param>
+        /// <param name="ignoreCase">Ignore the case from the pattern.</param>
+        /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
+        public RegexMatcher(MatchBehaviour matchBehaviour, [NotNull, RegexPattern] string[] patterns, bool ignoreCase = false, bool throwException = false)
+        {
+            Check.NotNull(patterns, nameof(patterns));
+
+            _patterns = patterns;
+            IgnoreCase = ignoreCase;
+            MatchBehaviour = matchBehaviour;
+            ThrowException = throwException;
+
+            RegexOptions options = RegexOptions.Compiled | RegexOptions.Multiline;
+
+            if (ignoreCase)
+            {
+                options |= RegexOptions.IgnoreCase;
             }
 
-            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
-        }
-
-        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
-        public virtual string[] GetPatterns()
-        {
-            return _patterns;
-        }
-
-        /// <inheritdoc cref="IMatcher.Name"/>
-        public virtual string Name => "RegexMatcher";
-
-        /// <inheritdoc cref="IIgnoreCaseMatcher.IgnoreCase"/>
-        public bool IgnoreCase { get; }
-    }
+            _expressions = patterns.Select(p => new Regex(p, options)).ToArray();
+        }
+
+        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
+        public virtual double IsMatch(string input)
+        {
+            double match = MatchScores.Mismatch;
+            if (input != null)
+            {
+                try
+                {
+                    match = MatchScores.ToScore(_expressions.Select(e => e.IsMatch(input)));
+                }
+                catch (Exception)
+                {
+                    if (ThrowException)
+                    {
+                        throw;
+                    }
+                }
+            }
+
+            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
+        }
+
+        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
+        public virtual string[] GetPatterns()
+        {
+            return _patterns;
+        }
+
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public virtual string Name => "RegexMatcher";
+
+        /// <inheritdoc cref="IIgnoreCaseMatcher.IgnoreCase"/>
+        public bool IgnoreCase { get; }
+    }
 }

src/WireMock.Net/Matchers/Request/RequestMessageBodyMatcher.cs

@@ -123,6 +123,22 @@ namespace WireMock.Matchers.Request
 
         private double CalculateMatchScore(IRequestMessage requestMessage, IMatcher matcher)
         {
+            if (matcher is NotNullOrEmptyMatcher notNullOrEmptyMatcher)
+            {
+                switch (requestMessage?.BodyData?.DetectedBodyType)
+                {
+                    case BodyType.Json:
+                    case BodyType.String:
+                        return notNullOrEmptyMatcher.IsMatch(requestMessage.BodyData.BodyAsString);
+
+                    case BodyType.Bytes:
+                        return notNullOrEmptyMatcher.IsMatch(requestMessage.BodyData.BodyAsBytes);
+
+                    default:
+                        return MatchScores.Mismatch;
+                }
+            }
+
             if (matcher is ExactObjectMatcher exactObjectMatcher)
             {
                 // If the body is a byte array, try to match.

src/WireMock.Net/Models/Webhook.cs

@@ -1,8 +1,4 @@
-using System.Collections.Generic;
-using JetBrains.Annotations;
-using WireMock.Types;
-
-namespace WireMock.Models
+namespace WireMock.Models
 {
     /// <summary>
     /// Webhook

src/WireMock.Net/Owin/AspNetCoreSelfHost.cs

@@ -66,6 +66,8 @@ namespace WireMock.Owin
                     services.AddSingleton<IMappingMatcher, MappingMatcher>();
                     services.AddSingleton<IOwinRequestMapper, OwinRequestMapper>();
                     services.AddSingleton<IOwinResponseMapper, OwinResponseMapper>();
+
+                    _wireMockMiddlewareOptions.AdditionalServiceRegistration?.Invoke(services);
                 })
                 .Configure(appBuilder =>
                 {

src/WireMock.Net/Owin/IWireMockMiddlewareOptions.cs

@@ -8,6 +8,7 @@ using WireMock.Util;
 using Owin;
 #else
 using IAppBuilder = Microsoft.AspNetCore.Builder.IApplicationBuilder;
+using Microsoft.Extensions.DependencyInjection;
 #endif
 
 namespace WireMock.Owin
@@ -36,6 +37,10 @@ namespace WireMock.Owin
 
         Action<IAppBuilder> PostWireMockMiddlewareInit { get; set; }
 
+#if USE_ASPNETCORE
+        Action<IServiceCollection> AdditionalServiceRegistration { get; set; }
+#endif
+
         IFileSystemHandler FileSystemHandler { get; set; }
 
         bool? AllowBodyForAllHttpMethods { get; set; }

src/WireMock.Net/Owin/WireMockMiddleware.cs

@@ -156,9 +156,9 @@ namespace WireMock.Owin
                     UpdateScenarioState(targetMapping);
                 }
 
-                if (!targetMapping.IsAdminInterface && targetMapping.Webhook != null)
+                if (!targetMapping.IsAdminInterface && targetMapping.Webhooks?.Length > 0)
                 {
-                    await SendToWebhookAsync(targetMapping, request, response).ConfigureAwait(false);
+                    await SendToWebhooksAsync(targetMapping, request, response).ConfigureAwait(false);
                 }
             }
             catch (Exception ex)
@@ -191,18 +191,21 @@ namespace WireMock.Owin
             await CompletedTask;
         }
 
-        private async Task SendToWebhookAsync(IMapping mapping, RequestMessage request, ResponseMessage response)
+        private async Task SendToWebhooksAsync(IMapping mapping, RequestMessage request, ResponseMessage response)
         {
-            var httpClientForWebhook = HttpClientBuilder.Build(mapping.Settings.WebhookSettings ?? new WebhookSettings());
-            var webhookSender = new WebhookSender(mapping.Settings);
+            for (int index = 0; index < mapping.Webhooks.Length; index++)
+            {
+                var httpClientForWebhook = HttpClientBuilder.Build(mapping.Settings.WebhookSettings ?? new WebhookSettings());
+                var webhookSender = new WebhookSender(mapping.Settings);
 
-            try
-            {
-                await webhookSender.SendAsync(httpClientForWebhook, mapping.Webhook.Request, request, response).ConfigureAwait(false);
-            }
-            catch (Exception ex)
-            {
-                _options.Logger.Error($"Sending message to Webhook Mapping '{mapping.Guid}' failed. Exception: {ex}");
+                try
+                {
+                    await webhookSender.SendAsync(httpClientForWebhook, mapping.Webhooks[index].Request, request, response).ConfigureAwait(false);
+                }
+                catch (Exception ex)
+                {
+                    _options.Logger.Error($"Sending message to Webhook [{index}] from Mapping '{mapping.Guid}' failed. Exception: {ex}");
+                }
             }
         }
 

src/WireMock.Net/Owin/WireMockMiddlewareOptions.cs

@@ -8,6 +8,7 @@ using WireMock.Util;
 using Owin;
 #else
 using IAppBuilder = Microsoft.AspNetCore.Builder.IApplicationBuilder;
+using Microsoft.Extensions.DependencyInjection;
 #endif
 
 namespace WireMock.Owin
@@ -36,6 +37,10 @@ namespace WireMock.Owin
 
         public Action<IAppBuilder> PostWireMockMiddlewareInit { get; set; }
 
+#if USE_ASPNETCORE
+        public Action<IServiceCollection> AdditionalServiceRegistration { get; set; }
+#endif
+
         /// <inheritdoc cref="IWireMockMiddlewareOptions.FileSystemHandler"/>
         public IFileSystemHandler FileSystemHandler { get; set; }
 

src/WireMock.Net/Serialization/MappingConverter.cs

@@ -84,10 +84,18 @@ namespace WireMock.Serialization
                 Response = new ResponseModel
                 {
                     Delay = (int?)response.Delay?.TotalMilliseconds
-                },
-                Webhook = WebhookMapper.Map(mapping.Webhook)
+                }
             };
 
+            if (mapping.Webhooks?.Length == 1)
+            {
+                mappingModel.Webhook = WebhookMapper.Map(mapping.Webhooks[0]);
+            }
+            else if (mapping.Webhooks?.Length > 1)
+            {
+                mappingModel.Webhooks = mapping.Webhooks.Select(WebhookMapper.Map).ToArray();
+            }
+
             if (bodyMatcher?.Matchers != null)
             {
                 mappingModel.Request.Body = new BodyModel();

src/WireMock.Net/Serialization/MatcherMapper.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using JetBrains.Annotations;
@@ -43,7 +43,10 @@ namespace WireMock.Serialization
             bool throwExceptionWhenMatcherFails = _settings.ThrowExceptionWhenMatcherFails == true;
 
             switch (matcherName)
-            {
+            {
+                case "NotNullOrEmptyMatcher":
+                    return new NotNullOrEmptyMatcher(matchBehaviour);
+
                 case "CSharpCodeMatcher":
                     if (_settings.AllowCSharpCodeMatcher == true)
                     {

src/WireMock.Net/Server/IRespondWithAProvider.cs

@@ -103,14 +103,14 @@ namespace WireMock.Server
         IRespondWithAProvider WillSetStateTo(int state, int? times = 1);
 
         /// <summary>
-        /// Add a Webbook to call after the response has been generated.
+        /// Add (multiple) Webhook(s) to call after the response has been generated.
         /// </summary>
-        /// <param name="webhook">The Webhook</param>
+        /// <param name="webhooks">The Webhooks</param>
         /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
-        IRespondWithAProvider WithWebhook(IWebhook webhook);
+        IRespondWithAProvider WithWebhook(params IWebhook[] webhooks);
 
         /// <summary>
-        /// Add a Webbook to call after the response has been generated.
+        /// Add a Webhook to call after the response has been generated.
         /// </summary>
         /// <param name="url">The Webhook Url</param>
         /// <param name="method">The method to use. [optional]</param>
@@ -129,7 +129,7 @@ namespace WireMock.Server
         );
 
         /// <summary>
-        /// Add a Webbook to call after the response has been generated.
+        /// Add a Webhook to call after the response has been generated.
         /// </summary>
         /// <param name="url">The Webhook Url</param>
         /// <param name="method">The method to use. [optional]</param>

src/WireMock.Net/Server/RespondWithAProvider.cs

@@ -1,209 +1,212 @@
-// This source file is based on mock4net by Alexandre Victoor which is licensed under the Apache 2.0 License.
-// For more details see 'mock4net/LICENSE.txt' and 'mock4net/readme.md' in this project root.
-using System;
+// This source file is based on mock4net by Alexandre Victoor which is licensed under the Apache 2.0 License.
+// For more details see 'mock4net/LICENSE.txt' and 'mock4net/readme.md' in this project root.
+using System;
 using System.Collections.Generic;
 using JetBrains.Annotations;
-using WireMock.Matchers.Request;
-using WireMock.Models;
-using WireMock.ResponseProviders;
-using WireMock.Settings;
+using WireMock.Matchers.Request;
+using WireMock.Models;
+using WireMock.ResponseProviders;
+using WireMock.Settings;
 using WireMock.Types;
 using WireMock.Util;
+using WireMock.Validation;
+
+namespace WireMock.Server
+{
+    /// <summary>
+    /// The respond with a provider.
+    /// </summary>
+    internal class RespondWithAProvider : IRespondWithAProvider
+    {
+        private int _priority;
+        private string _title;
+        private string _path;
+        private string _executionConditionState;
+        private string _nextState;
+        private string _scenario;
+        private int _timesInSameState = 1;
+        private readonly RegistrationCallback _registrationCallback;
+        private readonly IRequestMatcher _requestMatcher;
+        private readonly IWireMockServerSettings _settings;
+        private readonly bool _saveToFile;
+
+        public Guid Guid { get; private set; } = Guid.NewGuid();
+
+        public IWebhook[] Webhooks { get; private set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RespondWithAProvider"/> class.
+        /// </summary>
+        /// <param name="registrationCallback">The registration callback.</param>
+        /// <param name="requestMatcher">The request matcher.</param>
+        /// <param name="settings">The WireMockServerSettings.</param>
+        /// <param name="saveToFile">Optional boolean to indicate if this mapping should be saved as static mapping file.</param>
+        public RespondWithAProvider(RegistrationCallback registrationCallback, IRequestMatcher requestMatcher, IWireMockServerSettings settings, bool saveToFile = false)
+        {
+            _registrationCallback = registrationCallback;
+            _requestMatcher = requestMatcher;
+            _settings = settings;
+            _saveToFile = saveToFile;
+        }
+
+        /// <summary>
+        /// The respond with.
+        /// </summary>
+        /// <param name="provider">The provider.</param>
+        public void RespondWith(IResponseProvider provider)
+        {
+            _registrationCallback(new Mapping(Guid, _title, _path, _settings, _requestMatcher, provider, _priority, _scenario, _executionConditionState, _nextState, _timesInSameState, Webhooks), _saveToFile);
+        }
+
+        /// <see cref="IRespondWithAProvider.WithGuid(string)"/>
+        public IRespondWithAProvider WithGuid(string guid)
+        {
+            return WithGuid(Guid.Parse(guid));
+        }
+
+        /// <see cref="IRespondWithAProvider.WithGuid(Guid)"/>
+        public IRespondWithAProvider WithGuid(Guid guid)
+        {
+            Guid = guid;
+
+            return this;
+        }
+
+        /// <see cref="IRespondWithAProvider.WithTitle"/>
+        public IRespondWithAProvider WithTitle(string title)
+        {
+            _title = title;
+
+            return this;
+        }
+
+        /// <see cref="IRespondWithAProvider.WithPath"/>
+        public IRespondWithAProvider WithPath(string path)
+        {
+            _path = path;
+
+            return this;
+        }
+
+        /// <see cref="IRespondWithAProvider.AtPriority"/>
+        public IRespondWithAProvider AtPriority(int priority)
+        {
+            _priority = priority;
+
+            return this;
+        }
+
+        /// <see cref="IRespondWithAProvider.InScenario(string)"/>
+        public IRespondWithAProvider InScenario(string scenario)
+        {
+            _scenario = scenario;
+
+            return this;
+        }
+
+        /// <see cref="IRespondWithAProvider.InScenario(int)"/>
+        public IRespondWithAProvider InScenario(int scenario)
+        {
+            return InScenario(scenario.ToString());
+        }
+
+        /// <see cref="IRespondWithAProvider.WhenStateIs(string)"/>
+        public IRespondWithAProvider WhenStateIs(string state)
+        {
+            if (string.IsNullOrEmpty(_scenario))
+            {
+                throw new NotSupportedException("Unable to set state condition when no scenario is defined.");
+            }
+
+            _executionConditionState = state;
+
+            return this;
+        }
+
+        /// <see cref="IRespondWithAProvider.WhenStateIs(int)"/>
+        public IRespondWithAProvider WhenStateIs(int state)
+        {
+            return WhenStateIs(state.ToString());
+        }
+
+        /// <see cref="IRespondWithAProvider.WillSetStateTo(string, int?)"/>
+        public IRespondWithAProvider WillSetStateTo(string state, int? times = 1)
+        {
+            if (string.IsNullOrEmpty(_scenario))
+            {
+                throw new NotSupportedException("Unable to set next state when no scenario is defined.");
+            }
+
+            _nextState = state;
+            _timesInSameState = times ?? 1;
+
+            return this;
+        }
+
+        /// <see cref="IRespondWithAProvider.WillSetStateTo(int, int?)"/>
+        public IRespondWithAProvider WillSetStateTo(int state, int? times = 1)
+        {
+            return WillSetStateTo(state.ToString(), times);
+        }
+
+        /// <see cref="IRespondWithAProvider.WithWebhook(IWebhook[])"/>
+        public IRespondWithAProvider WithWebhook(params IWebhook[] webhooks)
+        {
+            Check.HasNoNulls(webhooks, nameof(webhooks));
+
+            Webhooks = webhooks;
+
+            return this;
+        }
+
+        /// <see cref="IRespondWithAProvider.WithWebhook(string, string, IDictionary{string, WireMockList{string}}, string, bool, TransformerType)"/>
+        public IRespondWithAProvider WithWebhook(
+            [NotNull] string url,
+            [CanBeNull] string method = "post",
+            [CanBeNull] IDictionary<string, WireMockList<string>> headers = null,
+            [CanBeNull] string body = null,
+            bool useTransformer = true,
+            TransformerType transformerType = TransformerType.Handlebars)
+        {
+            Webhooks = new[] { InitWebhook(url, method, headers, useTransformer, transformerType) };
 
-namespace WireMock.Server
-{
-    /// <summary>
-    /// The respond with a provider.
-    /// </summary>
-    internal class RespondWithAProvider : IRespondWithAProvider
-    {
-        private int _priority;
-        private string _title;
-        private string _path;
-        private string _executionConditionState;
-        private string _nextState;
-        private string _scenario;
-        private int _timesInSameState = 1;
-        private readonly RegistrationCallback _registrationCallback;
-        private readonly IRequestMatcher _requestMatcher;
-        private readonly IWireMockServerSettings _settings;
-        private readonly bool _saveToFile;
-
-        public Guid Guid { get; private set; } = Guid.NewGuid();
-
-        public IWebhook Webhook { get; private set; }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="RespondWithAProvider"/> class.
-        /// </summary>
-        /// <param name="registrationCallback">The registration callback.</param>
-        /// <param name="requestMatcher">The request matcher.</param>
-        /// <param name="settings">The WireMockServerSettings.</param>
-        /// <param name="saveToFile">Optional boolean to indicate if this mapping should be saved as static mapping file.</param>
-        public RespondWithAProvider(RegistrationCallback registrationCallback, IRequestMatcher requestMatcher, IWireMockServerSettings settings, bool saveToFile = false)
-        {
-            _registrationCallback = registrationCallback;
-            _requestMatcher = requestMatcher;
-            _settings = settings;
-            _saveToFile = saveToFile;
-        }
-
-        /// <summary>
-        /// The respond with.
-        /// </summary>
-        /// <param name="provider">The provider.</param>
-        public void RespondWith(IResponseProvider provider)
-        {
-            _registrationCallback(new Mapping(Guid, _title, _path, _settings, _requestMatcher, provider, _priority, _scenario, _executionConditionState, _nextState, _timesInSameState, Webhook), _saveToFile);
-        }
-
-        /// <see cref="IRespondWithAProvider.WithGuid(string)"/>
-        public IRespondWithAProvider WithGuid(string guid)
-        {
-            return WithGuid(Guid.Parse(guid));
-        }
-
-        /// <see cref="IRespondWithAProvider.WithGuid(Guid)"/>
-        public IRespondWithAProvider WithGuid(Guid guid)
-        {
-            Guid = guid;
-
-            return this;
-        }
-
-        /// <see cref="IRespondWithAProvider.WithTitle"/>
-        public IRespondWithAProvider WithTitle(string title)
-        {
-            _title = title;
-
-            return this;
-        }
-
-        /// <see cref="IRespondWithAProvider.WithPath"/>
-        public IRespondWithAProvider WithPath(string path)
-        {
-            _path = path;
-
-            return this;
-        }
-
-        /// <see cref="IRespondWithAProvider.AtPriority"/>
-        public IRespondWithAProvider AtPriority(int priority)
-        {
-            _priority = priority;
-
-            return this;
-        }
-
-        /// <see cref="IRespondWithAProvider.InScenario(string)"/>
-        public IRespondWithAProvider InScenario(string scenario)
-        {
-            _scenario = scenario;
-
-            return this;
-        }
-
-        /// <see cref="IRespondWithAProvider.InScenario(int)"/>
-        public IRespondWithAProvider InScenario(int scenario)
-        {
-            return InScenario(scenario.ToString());
-        }
-
-        /// <see cref="IRespondWithAProvider.WhenStateIs(string)"/>
-        public IRespondWithAProvider WhenStateIs(string state)
-        {
-            if (string.IsNullOrEmpty(_scenario))
-            {
-                throw new NotSupportedException("Unable to set state condition when no scenario is defined.");
-            }
-
-            _executionConditionState = state;
-
-            return this;
-        }
-
-        /// <see cref="IRespondWithAProvider.WhenStateIs(int)"/>
-        public IRespondWithAProvider WhenStateIs(int state)
-        {
-            return WhenStateIs(state.ToString());
-        }
-
-        /// <see cref="IRespondWithAProvider.WillSetStateTo(string, int?)"/>
-        public IRespondWithAProvider WillSetStateTo(string state, int? times = 1)
-        {
-            if (string.IsNullOrEmpty(_scenario))
-            {
-                throw new NotSupportedException("Unable to set next state when no scenario is defined.");
-            }
-
-            _nextState = state;
-            _timesInSameState = times ?? 1;
-
-            return this;
-        }
-
-        /// <see cref="IRespondWithAProvider.WillSetStateTo(int, int?)"/>
-        public IRespondWithAProvider WillSetStateTo(int state, int? times = 1)
-        {
-            return WillSetStateTo(state.ToString(), times);
-        }
-
-        /// <see cref="IRespondWithAProvider.WithWebhook(IWebhook)"/>
-        public IRespondWithAProvider WithWebhook(IWebhook webhook)
-        {
-            Webhook = webhook;
-
-            return this;
-        }
-
-        /// <see cref="IRespondWithAProvider.WithWebhook(string,string, IDictionary{string, WireMockList{string}}, string, bool, TransformerType)"/>
-        public IRespondWithAProvider WithWebhook(
-            [NotNull] string url,
-            [CanBeNull] string method = "post",
-            [CanBeNull] IDictionary<string, WireMockList<string>> headers = null,
-            [CanBeNull] string body = null,
-            bool useTransformer = true,
-            TransformerType transformerType = TransformerType.Handlebars)
-        {
-            Webhook = InitWebhook(url, method, headers, useTransformer, transformerType);
-
             if (body != null)
             {
-                Webhook.Request.BodyData = new BodyData
+                Webhooks[0].Request.BodyData = new BodyData
                 {
                     BodyAsString = body,
                     DetectedBodyType = BodyType.String,
                     DetectedBodyTypeFromContentType = BodyType.String
                 };
-            }
-
-            return this;
+            }
+
+            return this;
         }
 
-        /// <see cref="IRespondWithAProvider.WithWebhook(string, string, IDictionary{string, WireMockList{string}}, object, bool, TransformerType)"/>
-        public IRespondWithAProvider WithWebhook(
-            [NotNull] string url,
-            [CanBeNull] string method = "post",
-            [CanBeNull] IDictionary<string, WireMockList<string>> headers = null,
-            [CanBeNull] object body = null,
-            bool useTransformer = true,
-            TransformerType transformerType = TransformerType.Handlebars)
-        {
-            Webhook = InitWebhook(url, method, headers, useTransformer, transformerType);
-
+        /// <see cref="IRespondWithAProvider.WithWebhook(string, string, IDictionary{string, WireMockList{string}}, object, bool, TransformerType)"/>
+        public IRespondWithAProvider WithWebhook(
+            [NotNull] string url,
+            [CanBeNull] string method = "post",
+            [CanBeNull] IDictionary<string, WireMockList<string>> headers = null,
+            [CanBeNull] object body = null,
+            bool useTransformer = true,
+            TransformerType transformerType = TransformerType.Handlebars)
+        {
+            Webhooks = new[] { InitWebhook(url, method, headers, useTransformer, transformerType) };
+
             if (body != null)
             {
-                Webhook.Request.BodyData = new BodyData
+                Webhooks[0].Request.BodyData = new BodyData
                 {
                     BodyAsJson = body,
                     DetectedBodyType = BodyType.Json,
                     DetectedBodyTypeFromContentType = BodyType.Json
                 };
-            }
-
-            return this;
-        }
-
+            }
+
+            return this;
+        }
+
         private IWebhook InitWebhook(
             string url,
             string method,
@@ -222,6 +225,6 @@ namespace WireMock.Server
                     TransformerType = transformerType
                 }
             };
-        }
-    }
+        }
+    }
 }

src/WireMock.Net/Server/WireMockServer.Admin.cs

@@ -470,10 +470,15 @@ namespace WireMock.Server
                 respondProvider = respondProvider.WillSetStateTo(mappingModel.SetStateTo);
             }
 
-            if (mappingModel.Webhook?.Request != null)
+            if (mappingModel.Webhook != null)
             {
                 respondProvider = respondProvider.WithWebhook(WebhookMapper.Map(mappingModel.Webhook));
             }
+            else if (mappingModel.Webhooks?.Length > 1)
+            {
+                var webhooks = mappingModel.Webhooks.Select(WebhookMapper.Map).ToArray();
+                respondProvider = respondProvider.WithWebhook(webhooks);
+            }
 
             respondProvider.RespondWith(responseBuilder);
 

src/WireMock.Net/Server/WireMockServer.cs

@@ -242,6 +242,7 @@ namespace WireMock.Server
             _mappingToFileSaver = new MappingToFileSaver(_settings, _mappingConverter);
 
 #if USE_ASPNETCORE
+            _options.AdditionalServiceRegistration = _settings.AdditionalServiceRegistration;
             _httpServer = new AspNetCoreSelfHost(_options, urlOptions);
 #else
             _httpServer = new OwinSelfHost(_options, urlOptions);

src/WireMock.Net/Settings/IWireMockServerSettings.cs

@@ -4,6 +4,9 @@ using JetBrains.Annotations;
 using WireMock.Handlers;
 using WireMock.Logging;
 using WireMock.Matchers;
+#if USE_ASPNETCORE
+using Microsoft.Extensions.DependencyInjection;
+#endif
 
 namespace WireMock.Settings
 {
@@ -109,6 +112,14 @@ namespace WireMock.Settings
         [PublicAPI]
         Action<object> PostWireMockMiddlewareInit { get; set; }
 
+#if USE_ASPNETCORE
+        /// <summary>
+        /// Action which is called with IServiceCollection when ASP.NET Core DI is being configured. [Optional]
+        /// </summary>
+        [PublicAPI]
+        Action<IServiceCollection> AdditionalServiceRegistration { get; set; }
+#endif
+
         /// <summary>
         /// The IWireMockLogger which logs Debug, Info, Warning or Error
         /// </summary>

src/WireMock.Net/Settings/WireMockServerSettings.cs

@@ -4,6 +4,9 @@ using JetBrains.Annotations;
 using Newtonsoft.Json;
 using WireMock.Handlers;
 using WireMock.Logging;
+#if USE_ASPNETCORE
+using Microsoft.Extensions.DependencyInjection;
+#endif
 
 namespace WireMock.Settings
 {
@@ -79,6 +82,13 @@ namespace WireMock.Settings
         [JsonIgnore]
         public Action<object> PostWireMockMiddlewareInit { get; set; }
 
+#if USE_ASPNETCORE
+        /// <inheritdoc cref="IWireMockServerSettings.AdditionalServiceRegistration"/>
+        [PublicAPI]
+        [JsonIgnore]
+        public Action<IServiceCollection> AdditionalServiceRegistration { get; set; }
+#endif
+
         /// <inheritdoc cref="IWireMockServerSettings.Logger"/>
         [PublicAPI]
         [JsonIgnore]

src/WireMock.Net/WireMock.Net.csproj

@@ -121,13 +121,16 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Handlebars.Net.Helpers" Version="2.1.2" />
-    <PackageReference Include="Handlebars.Net.Helpers.DynamicLinq" Version="2.1.2" />
-    <PackageReference Include="Handlebars.Net.Helpers.Json" Version="2.1.2" />
-    <PackageReference Include="Handlebars.Net.Helpers.XPath" Version="2.1.2" />
-    <PackageReference Include="Handlebars.Net.Helpers.Xeger" Version="2.1.2" />
-    <PackageReference Include="Handlebars.Net.Helpers.Random" Version="2.1.2" />
+    <PackageReference Include="Handlebars.Net.Helpers" Version="2.2.1" />
+    <PackageReference Include="Handlebars.Net.Helpers.DynamicLinq" Version="2.2.1" />
+    <PackageReference Include="Handlebars.Net.Helpers.Humanizer" Version="2.2.1" />
+    <PackageReference Include="Handlebars.Net.Helpers.Json" Version="2.2.1" />
+    <PackageReference Include="Handlebars.Net.Helpers.XPath" Version="2.2.1" />
+    <PackageReference Include="Handlebars.Net.Helpers.Xeger" Version="2.2.1" />
+    <PackageReference Include="Handlebars.Net.Helpers.Random" Version="2.2.1" />
+  </ItemGroup>
 
+  <ItemGroup>
     <ProjectReference Include="..\WireMock.Net.Abstractions\WireMock.Net.Abstractions.csproj" />
   </ItemGroup>
 </Project>

test/WireMock.Net.Tests/Http/HttpRequestMessageHelperTests.cs

@@ -1,6 +1,7 @@
 using NFluent;
 using System.Collections.Generic;
 using System.Text;
+using System.Threading.Tasks;
 using WireMock.Http;
 using WireMock.Models;
 using WireMock.Types;
@@ -28,7 +29,7 @@ namespace WireMock.Net.Tests.Http
         }
 
         [Fact]
-        public async void HttpRequestMessageHelper_Create_Bytes()
+        public async Task HttpRequestMessageHelper_Create_Bytes()
         {
             // Assign
             var body = new BodyData
@@ -46,7 +47,7 @@ namespace WireMock.Net.Tests.Http
         }
 
         [Fact]
-        public async void HttpRequestMessageHelper_Create_Json()
+        public async Task HttpRequestMessageHelper_Create_Json()
         {
             // Assign
             var body = new BodyData
@@ -64,7 +65,7 @@ namespace WireMock.Net.Tests.Http
         }
 
         [Fact]
-        public async void HttpRequestMessageHelper_Create_Json_With_ContentType_ApplicationJson()
+        public async Task HttpRequestMessageHelper_Create_Json_With_ContentType_ApplicationJson()
         {
             // Assign
             var headers = new Dictionary<string, string[]> { { "Content-Type", new[] { "application/json" } } };
@@ -84,7 +85,7 @@ namespace WireMock.Net.Tests.Http
         }
 
         [Fact]
-        public async void HttpRequestMessageHelper_Create_Json_With_ContentType_ApplicationJson_UTF8()
+        public async Task HttpRequestMessageHelper_Create_Json_With_ContentType_ApplicationJson_UTF8()
         {
             // Assign
             var headers = new Dictionary<string, string[]> { { "Content-Type", new[] { "application/json; charset=utf-8" } } };

test/WireMock.Net.Tests/Matchers/NotNullOrEmptyMatcherTests.cs

@@ -0,0 +1,60 @@
+using FluentAssertions;
+using NFluent;
+using WireMock.Matchers;
+using Xunit;
+
+namespace WireMock.Net.Tests.Matchers
+{
+    public class NotNullOrEmptyMatcherTests
+    {
+        [Fact]
+        public void NotNullOrEmptyMatcher_GetName()
+        {
+            // Act
+            var matcher = new NotNullOrEmptyMatcher();
+            string name = matcher.Name;
+
+            // Assert
+            Check.That(name).Equals("NotNullOrEmptyMatcher");
+        }
+
+        [Theory]
+        [InlineData(null, 0.0)]
+        [InlineData(new byte[0], 0.0)]
+        [InlineData(new byte[] { 48 }, 1.0)]
+        public void NotNullOrEmptyMatcher_IsMatch_ByteArray(byte[] data, double expected)
+        {
+            // Act
+            var matcher = new NotNullOrEmptyMatcher();
+            double result = matcher.IsMatch(data);
+
+            // Assert
+            result.Should().Be(expected);
+        }
+
+        [Theory]
+        [InlineData(null, 0.0)]
+        [InlineData("", 0.0)]
+        [InlineData("x", 1.0)]
+        public void NotNullOrEmptyMatcher_IsMatch_String(string data, double expected)
+        {
+            // Act
+            var matcher = new NotNullOrEmptyMatcher();
+            double result = matcher.IsMatch(data);
+
+            // Assert
+            result.Should().Be(expected);
+        }
+
+        [Fact]
+        public void NotNullOrEmptyMatcher_IsMatch_Json()
+        {
+            // Act
+            var matcher = new NotNullOrEmptyMatcher();
+            double result = matcher.IsMatch(new { x = "x" });
+
+            // Assert
+            result.Should().Be(1.0);
+        }
+    }
+}

test/WireMock.Net.Tests/ObservableLogEntriesTest.cs

@@ -19,7 +19,7 @@ namespace WireMock.Net.Tests
     public class ObservableLogEntriesTest
     {
         [Fact]
-        public async void WireMockServer_LogEntriesChanged_WithException_Should_LogError()
+        public async Task WireMockServer_LogEntriesChanged_WithException_Should_LogError()
         {
             // Assign
             string path = $"/log_{Guid.NewGuid()}";
@@ -48,7 +48,7 @@ namespace WireMock.Net.Tests
         }
 
         [Fact]
-        public async void WireMockServer_LogEntriesChanged()
+        public async Task WireMockServer_LogEntriesChanged()
         {
             // Assign
             string path = $"/log_{Guid.NewGuid()}";

test/WireMock.Net.Tests/Owin/WireMockMiddlewareTests.cs

@@ -77,7 +77,7 @@ namespace WireMock.Net.Tests.Owin
         }
 
         [Fact]
-        public async void WireMockMiddleware_Invoke_NoMatch()
+        public async Task WireMockMiddleware_Invoke_NoMatch()
         {
             // Act
             await _sut.Invoke(_contextMock.Object);
@@ -90,7 +90,7 @@ namespace WireMock.Net.Tests.Owin
         }
 
         [Fact]
-        public async void WireMockMiddleware_Invoke_IsAdminInterface_EmptyHeaders_401()
+        public async Task WireMockMiddleware_Invoke_IsAdminInterface_EmptyHeaders_401()
         {
             // Assign
             var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1", null, new Dictionary<string, string[]>());
@@ -113,7 +113,7 @@ namespace WireMock.Net.Tests.Owin
         }
 
         [Fact]
-        public async void WireMockMiddleware_Invoke_IsAdminInterface_MissingHeader_401()
+        public async Task WireMockMiddleware_Invoke_IsAdminInterface_MissingHeader_401()
         {
             // Assign
             var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1", null, new Dictionary<string, string[]> { { "h", new[] { "x" } } });
@@ -136,7 +136,7 @@ namespace WireMock.Net.Tests.Owin
         }
 
         [Fact]
-        public async void WireMockMiddleware_Invoke_RequestLogExpirationDurationIsDefined()
+        public async Task WireMockMiddleware_Invoke_RequestLogExpirationDurationIsDefined()
         {
             // Assign
             _optionsMock.SetupGet(o => o.RequestLogExpirationDuration).Returns(1);
@@ -146,7 +146,7 @@ namespace WireMock.Net.Tests.Owin
         }
 
         [Fact]
-        public async void WireMockMiddleware_Invoke_Mapping_Has_ProxyAndRecordSettings_And_SaveMapping_Is_True()
+        public async Task WireMockMiddleware_Invoke_Mapping_Has_ProxyAndRecordSettings_And_SaveMapping_Is_True()
         {
             // Assign
             var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1", null, new Dictionary<string, string[]>());
@@ -195,7 +195,7 @@ namespace WireMock.Net.Tests.Owin
         }
 
         [Fact]
-        public async void WireMockMiddleware_Invoke_Mapping_Has_ProxyAndRecordSettings_And_SaveMapping_Is_False_But_WireMockServerSettings_SaveMapping_Is_True()
+        public async Task WireMockMiddleware_Invoke_Mapping_Has_ProxyAndRecordSettings_And_SaveMapping_Is_False_But_WireMockServerSettings_SaveMapping_Is_True()
         {
             // Assign
             var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1", null, new Dictionary<string, string[]>());

test/WireMock.Net.Tests/RequestMatchers/RequestMessageBodyMatcherTests.cs

@@ -1,328 +1,377 @@
-using System;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Moq;
-using NFluent;
-using WireMock.Matchers;
-using WireMock.Matchers.Request;
-using WireMock.Models;
-using WireMock.Types;
-using WireMock.Util;
-using Xunit;
-
-namespace WireMock.Net.Tests.RequestMatchers
-{
-    public class RequestMessageBodyMatcherTests
-    {
-        [Fact]
-        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsString_IStringMatcher()
-        {
-            // Assign
-            var body = new BodyData
-            {
-                BodyAsString = "b",
-                DetectedBodyType = BodyType.String
-            };
-            var stringMatcherMock = new Mock<IStringMatcher>();
-            stringMatcherMock.Setup(m => m.IsMatch(It.IsAny<string>())).Returns(0.5d);
-
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
-
-            var matcher = new RequestMessageBodyMatcher(stringMatcherMock.Object);
-
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
-
-            // Assert
-            Check.That(score).IsEqualTo(0.5d);
-
-            // Verify
-            stringMatcherMock.Verify(m => m.GetPatterns(), Times.Never);
-            stringMatcherMock.Verify(m => m.IsMatch("b"), Times.Once);
-        }
-
-        [Fact]
-        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsString_IStringMatchers()
-        {
-            // Assign
-            var body = new BodyData
-            {
-                BodyAsString = "b",
-                DetectedBodyType = BodyType.String
-            };
-            var stringMatcherMock1 = new Mock<IStringMatcher>();
-            stringMatcherMock1.Setup(m => m.IsMatch(It.IsAny<string>())).Returns(0.2d);
-            var stringMatcherMock2 = new Mock<IStringMatcher>();
-            stringMatcherMock2.Setup(m => m.IsMatch(It.IsAny<string>())).Returns(0.8d);
-            var matchers = new[] { stringMatcherMock1.Object, stringMatcherMock2.Object };
-
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
-
-            var matcher = new RequestMessageBodyMatcher(matchers.Cast<IMatcher>().ToArray());
-
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
-
-            // Assert
-            Check.That(score).IsEqualTo(0.8d);
-
-            // Verify
-            stringMatcherMock1.Verify(m => m.GetPatterns(), Times.Never);
-            stringMatcherMock1.Verify(m => m.IsMatch("b"), Times.Once);
-            stringMatcherMock2.Verify(m => m.GetPatterns(), Times.Never);
-            stringMatcherMock2.Verify(m => m.IsMatch("b"), Times.Once);
-        }
-
-        [Fact]
-        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsBytes_IStringMatcher()
-        {
-            // Assign
-            var body = new BodyData
-            {
-                BodyAsBytes = new byte[] { 1 },
-                DetectedBodyType = BodyType.Bytes
-            };
-            var stringMatcherMock = new Mock<IStringMatcher>();
-            stringMatcherMock.Setup(m => m.IsMatch(It.IsAny<string>())).Returns(0.5d);
-
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
-
-            var matcher = new RequestMessageBodyMatcher(stringMatcherMock.Object);
-
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
-
-            // Assert
-            Check.That(score).IsEqualTo(0.0d);
-
-            // Verify
-            stringMatcherMock.Verify(m => m.GetPatterns(), Times.Never);
-            stringMatcherMock.Verify(m => m.IsMatch(It.IsAny<string>()), Times.Never);
-        }
-
-        [Fact]
-        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsJson_IStringMatcher()
-        {
-            // Assign
-            var body = new BodyData
-            {
-                BodyAsJson = new { value = 42 },
-                DetectedBodyType = BodyType.Json
-            };
-            var stringMatcherMock = new Mock<IStringMatcher>();
-            stringMatcherMock.Setup(m => m.IsMatch(It.IsAny<string>())).Returns(0.5d);
-
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
-
-            var matcher = new RequestMessageBodyMatcher(stringMatcherMock.Object);
-
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
-
-            // Assert
-            Check.That(score).IsEqualTo(0.5d);
-
-            // Verify
-            stringMatcherMock.Verify(m => m.IsMatch(It.IsAny<string>()), Times.Once);
-        }
-
-        [Fact]
-        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsJson_and_BodyAsString_IStringMatcher()
-        {
-            // Assign
-            var body = new BodyData
-            {
-                BodyAsJson = new { value = 42 },
-                BodyAsString = "orig",
-                DetectedBodyType = BodyType.Json
-            };
-            var stringMatcherMock = new Mock<IStringMatcher>();
-            stringMatcherMock.Setup(m => m.IsMatch(It.IsAny<string>())).Returns(0.5d);
-
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
-
-            var matcher = new RequestMessageBodyMatcher(stringMatcherMock.Object);
-
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
-
-            // Assert
-            Check.That(score).IsEqualTo(0.5d);
-
-            // Verify
-            stringMatcherMock.Verify(m => m.IsMatch(It.IsAny<string>()), Times.Once);
-        }
-
-        [Fact]
-        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsJson_IObjectMatcher()
-        {
-            // Assign
-            var body = new BodyData
-            {
-                BodyAsJson = 42,
-                DetectedBodyType = BodyType.Json
-            };
-            var objectMatcherMock = new Mock<IObjectMatcher>();
-            objectMatcherMock.Setup(m => m.IsMatch(It.IsAny<object>())).Returns(0.5d);
-
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
-
-            var matcher = new RequestMessageBodyMatcher(objectMatcherMock.Object);
-
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
-
-            // Assert
-            Check.That(score).IsEqualTo(0.5d);
-
-            // Verify
-            objectMatcherMock.Verify(m => m.IsMatch(42), Times.Once);
-        }
-
-        [Fact]
-        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsJson_CSharpCodeMatcher()
-        {
-            // Assign
-            var body = new BodyData
-            {
-                BodyAsJson = new { value = 42 },
-                DetectedBodyType = BodyType.Json
-            };
-
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
-
-            var matcher = new RequestMessageBodyMatcher(new CSharpCodeMatcher(MatchBehaviour.AcceptOnMatch, "return it.value == 42;"));
-
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
-
-            // Assert
-            Check.That(score).IsEqualTo(1.0d);
-        }
-
-        [Theory]
-        [InlineData(new byte[] { 1 })]
-        [InlineData(new byte[] { 48 })]
-        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsBytes_IObjectMatcher(byte[] bytes)
-        {
-            // Assign
-            var body = new BodyData
-            {
-                BodyAsBytes = bytes,
-                DetectedBodyType = BodyType.Bytes
-            };
-            var objectMatcherMock = new Mock<IObjectMatcher>();
-            objectMatcherMock.Setup(m => m.IsMatch(It.IsAny<object>())).Returns(0.5d);
-
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
-
-            var matcher = new RequestMessageBodyMatcher(objectMatcherMock.Object);
-
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
-
-            // Assert
-            Check.That(score).IsEqualTo(0.5d);
-
-            // Verify
-            objectMatcherMock.Verify(m => m.IsMatch(It.IsAny<byte[]>()), Times.Once);
-        }
-
-        [Theory]
-        [MemberData(nameof(MatchingScoreData))]
-        public async Task RequestMessageBodyMatcher_GetMatchingScore_Funcs_Matching(object body, RequestMessageBodyMatcher matcher, bool shouldMatch)
-        {
-            // assign
-            BodyData bodyData;
-            if (body is byte[] b)
-            {
-                var bodyParserSettings = new BodyParserSettings
-                {
-                    Stream = new MemoryStream(b),
-                    ContentType = null,
-                    DeserializeJson = true
-                };
-                bodyData = await BodyParser.Parse(bodyParserSettings);
-            }
-            else if (body is string s)
-            {
-                var bodyParserSettings = new BodyParserSettings
-                {
-                    Stream = new MemoryStream(Encoding.UTF8.GetBytes(s)),
-                    ContentType = null,
-                    DeserializeJson = true
-                };
-                bodyData = await BodyParser.Parse(bodyParserSettings);
-            }
-            else
-            {
-                throw new Exception();
-            }
-
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", bodyData);
-
-            // act
-            var result = new RequestMatchResult();
-            var score = matcher.GetMatchingScore(requestMessage, result);
-
-            // assert
-            Check.That(score).IsEqualTo(shouldMatch ? 1d : 0d);
-        }
-
-        public static TheoryData<object, RequestMessageBodyMatcher, bool> MatchingScoreData
-        {
-            get
-            {
-                var json = "{'a':'b'}";
-                var str = "HelloWorld";
-                var bytes = new byte[] { 0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00 };
-
-                return new TheoryData<object, RequestMessageBodyMatcher, bool>
-                {
-                    // JSON match +++
-                    {json, new RequestMessageBodyMatcher((object o) => ((dynamic) o).a == "b"), true},
-                    {json, new RequestMessageBodyMatcher((string s) => s == json), true},
-                    {json, new RequestMessageBodyMatcher((byte[] b) => b.SequenceEqual(Encoding.UTF8.GetBytes(json))), true},
-                    
-                    // JSON no match ---
-                    {json, new RequestMessageBodyMatcher((object o) => false), false},
-                    {json, new RequestMessageBodyMatcher((string s) => false), false},
-                    {json, new RequestMessageBodyMatcher((byte[] b) => false), false},
-                    {json, new RequestMessageBodyMatcher(), false },
-                    
-                    // string match +++
-                    {str, new RequestMessageBodyMatcher((object o) => o == null), true},
-                    {str, new RequestMessageBodyMatcher((string s) => s == str), true},
-                    {str, new RequestMessageBodyMatcher((byte[] b) => b.SequenceEqual(Encoding.UTF8.GetBytes(str))), true},
-
-                    // string no match ---
-                    {str, new RequestMessageBodyMatcher((object o) => false), false},
-                    {str, new RequestMessageBodyMatcher((string s) => false), false},
-                    {str, new RequestMessageBodyMatcher((byte[] b) => false), false},
-                    {str, new RequestMessageBodyMatcher(), false },
-                    
-                    // binary match +++
-                    {bytes, new RequestMessageBodyMatcher((object o) => o == null), true},
-                    {bytes, new RequestMessageBodyMatcher((string s) => s == null), true},
-                    {bytes, new RequestMessageBodyMatcher((byte[] b) => b.SequenceEqual(bytes)), true},
-
-                    // binary no match ---
-                    {bytes, new RequestMessageBodyMatcher((object o) => false), false},
-                    {bytes, new RequestMessageBodyMatcher((string s) => false), false},
-                    {bytes, new RequestMessageBodyMatcher((byte[] b) => false), false},
-                    {bytes, new RequestMessageBodyMatcher(), false },
-                };
-            }
-        }
-    }
-}
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Moq;
+using NFluent;
+using WireMock.Matchers;
+using WireMock.Matchers.Request;
+using WireMock.Models;
+using WireMock.Types;
+using WireMock.Util;
+using Xunit;
+
+namespace WireMock.Net.Tests.RequestMatchers
+{
+    public class RequestMessageBodyMatcherTests
+    {
+        [Fact]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsString_IStringMatcher()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsString = "b",
+                DetectedBodyType = BodyType.String
+            };
+            var stringMatcherMock = new Mock<IStringMatcher>();
+            stringMatcherMock.Setup(m => m.IsMatch(It.IsAny<string>())).Returns(0.5d);
+
+            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(stringMatcherMock.Object);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.5d);
+
+            // Verify
+            stringMatcherMock.Verify(m => m.GetPatterns(), Times.Never);
+            stringMatcherMock.Verify(m => m.IsMatch("b"), Times.Once);
+        }
+
+        [Fact]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsString_IStringMatchers()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsString = "b",
+                DetectedBodyType = BodyType.String
+            };
+            var stringMatcherMock1 = new Mock<IStringMatcher>();
+            stringMatcherMock1.Setup(m => m.IsMatch(It.IsAny<string>())).Returns(0.2d);
+            var stringMatcherMock2 = new Mock<IStringMatcher>();
+            stringMatcherMock2.Setup(m => m.IsMatch(It.IsAny<string>())).Returns(0.8d);
+            var matchers = new[] { stringMatcherMock1.Object, stringMatcherMock2.Object };
+
+            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(matchers.Cast<IMatcher>().ToArray());
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.8d);
+
+            // Verify
+            stringMatcherMock1.Verify(m => m.GetPatterns(), Times.Never);
+            stringMatcherMock1.Verify(m => m.IsMatch("b"), Times.Once);
+            stringMatcherMock2.Verify(m => m.GetPatterns(), Times.Never);
+            stringMatcherMock2.Verify(m => m.IsMatch("b"), Times.Once);
+        }
+
+        [Fact]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsBytes_IStringMatcher()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsBytes = new byte[] { 1 },
+                DetectedBodyType = BodyType.Bytes
+            };
+            var stringMatcherMock = new Mock<IStringMatcher>();
+            stringMatcherMock.Setup(m => m.IsMatch(It.IsAny<string>())).Returns(0.5d);
+
+            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(stringMatcherMock.Object);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.0d);
+
+            // Verify
+            stringMatcherMock.Verify(m => m.GetPatterns(), Times.Never);
+            stringMatcherMock.Verify(m => m.IsMatch(It.IsAny<string>()), Times.Never);
+        }
+
+        [Fact]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsJson_IStringMatcher()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsJson = new { value = 42 },
+                DetectedBodyType = BodyType.Json
+            };
+            var stringMatcherMock = new Mock<IStringMatcher>();
+            stringMatcherMock.Setup(m => m.IsMatch(It.IsAny<string>())).Returns(0.5d);
+
+            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(stringMatcherMock.Object);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.5d);
+
+            // Verify
+            stringMatcherMock.Verify(m => m.IsMatch(It.IsAny<string>()), Times.Once);
+        }
+
+        [Fact]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsJson_and_BodyAsString_IStringMatcher()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsJson = new { value = 42 },
+                BodyAsString = "orig",
+                DetectedBodyType = BodyType.Json
+            };
+            var stringMatcherMock = new Mock<IStringMatcher>();
+            stringMatcherMock.Setup(m => m.IsMatch(It.IsAny<string>())).Returns(0.5d);
+
+            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(stringMatcherMock.Object);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.5d);
+
+            // Verify
+            stringMatcherMock.Verify(m => m.IsMatch(It.IsAny<string>()), Times.Once);
+        }
+
+        [Fact]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsJson_IObjectMatcher()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsJson = 42,
+                DetectedBodyType = BodyType.Json
+            };
+            var objectMatcherMock = new Mock<IObjectMatcher>();
+            objectMatcherMock.Setup(m => m.IsMatch(It.IsAny<object>())).Returns(0.5d);
+
+            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(objectMatcherMock.Object);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.5d);
+
+            // Verify
+            objectMatcherMock.Verify(m => m.IsMatch(42), Times.Once);
+        }
+
+        [Fact]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsJson_CSharpCodeMatcher()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsJson = new { value = 42 },
+                DetectedBodyType = BodyType.Json
+            };
+
+            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(new CSharpCodeMatcher(MatchBehaviour.AcceptOnMatch, "return it.value == 42;"));
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(1.0d);
+        }
+
+        [Theory]
+        [InlineData(null, 0.0)]
+        [InlineData(new byte[0], 0.0)]
+        [InlineData(new byte[] { 48 }, 1.0)]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsBytes_NotNullOrEmptyObjectMatcher(byte[] bytes, double expected)
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsBytes = bytes,
+                DetectedBodyType = BodyType.Bytes
+            };
+            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(new NotNullOrEmptyMatcher());
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            score.Should().Be(expected);
+        }
+
+        [Theory]
+        [InlineData(null, 0.0)]
+        [InlineData("", 0.0)]
+        [InlineData("x", 1.0)]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsString_NotNullOrEmptyObjectMatcher(string data, double expected)
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsString = data,
+                DetectedBodyType = BodyType.String
+            };
+            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(new NotNullOrEmptyMatcher());
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            score.Should().Be(expected);
+        }
+
+        [Theory]
+        [InlineData(new byte[] { 1 })]
+        [InlineData(new byte[] { 48 })]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsBytes_IObjectMatcher(byte[] bytes)
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsBytes = bytes,
+                DetectedBodyType = BodyType.Bytes
+            };
+            var objectMatcherMock = new Mock<IObjectMatcher>();
+            objectMatcherMock.Setup(m => m.IsMatch(It.IsAny<object>())).Returns(0.5d);
+
+            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(objectMatcherMock.Object);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.5d);
+
+            // Verify
+            objectMatcherMock.Verify(m => m.IsMatch(It.IsAny<byte[]>()), Times.Once);
+        }
+
+        [Theory]
+        [MemberData(nameof(MatchingScoreData))]
+        public async Task RequestMessageBodyMatcher_GetMatchingScore_Funcs_Matching(object body, RequestMessageBodyMatcher matcher, bool shouldMatch)
+        {
+            // assign
+            BodyData bodyData;
+            if (body is byte[] b)
+            {
+                var bodyParserSettings = new BodyParserSettings
+                {
+                    Stream = new MemoryStream(b),
+                    ContentType = null,
+                    DeserializeJson = true
+                };
+                bodyData = await BodyParser.Parse(bodyParserSettings);
+            }
+            else if (body is string s)
+            {
+                var bodyParserSettings = new BodyParserSettings
+                {
+                    Stream = new MemoryStream(Encoding.UTF8.GetBytes(s)),
+                    ContentType = null,
+                    DeserializeJson = true
+                };
+                bodyData = await BodyParser.Parse(bodyParserSettings);
+            }
+            else
+            {
+                throw new Exception();
+            }
+
+            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", bodyData);
+
+            // act
+            var result = new RequestMatchResult();
+            var score = matcher.GetMatchingScore(requestMessage, result);
+
+            // assert
+            Check.That(score).IsEqualTo(shouldMatch ? 1d : 0d);
+        }
+
+        public static TheoryData<object, RequestMessageBodyMatcher, bool> MatchingScoreData
+        {
+            get
+            {
+                var json = "{'a':'b'}";
+                var str = "HelloWorld";
+                var bytes = new byte[] { 0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00 };
+
+                return new TheoryData<object, RequestMessageBodyMatcher, bool>
+                {
+                    // JSON match +++
+                    {json, new RequestMessageBodyMatcher((object o) => ((dynamic) o).a == "b"), true},
+                    {json, new RequestMessageBodyMatcher((string s) => s == json), true},
+                    {json, new RequestMessageBodyMatcher((byte[] b) => b.SequenceEqual(Encoding.UTF8.GetBytes(json))), true},
+                    
+                    // JSON no match ---
+                    {json, new RequestMessageBodyMatcher((object o) => false), false},
+                    {json, new RequestMessageBodyMatcher((string s) => false), false},
+                    {json, new RequestMessageBodyMatcher((byte[] b) => false), false},
+                    {json, new RequestMessageBodyMatcher(), false },
+                    
+                    // string match +++
+                    {str, new RequestMessageBodyMatcher((object o) => o == null), true},
+                    {str, new RequestMessageBodyMatcher((string s) => s == str), true},
+                    {str, new RequestMessageBodyMatcher((byte[] b) => b.SequenceEqual(Encoding.UTF8.GetBytes(str))), true},
+
+                    // string no match ---
+                    {str, new RequestMessageBodyMatcher((object o) => false), false},
+                    {str, new RequestMessageBodyMatcher((string s) => false), false},
+                    {str, new RequestMessageBodyMatcher((byte[] b) => false), false},
+                    {str, new RequestMessageBodyMatcher(), false },
+                    
+                    // binary match +++
+                    {bytes, new RequestMessageBodyMatcher((object o) => o == null), true},
+                    {bytes, new RequestMessageBodyMatcher((string s) => s == null), true},
+                    {bytes, new RequestMessageBodyMatcher((byte[] b) => b.SequenceEqual(bytes)), true},
+
+                    // binary no match ---
+                    {bytes, new RequestMessageBodyMatcher((object o) => false), false},
+                    {bytes, new RequestMessageBodyMatcher((string s) => false), false},
+                    {bytes, new RequestMessageBodyMatcher((byte[] b) => false), false},
+                    {bytes, new RequestMessageBodyMatcher(), false },
+                };
+            }
+        }
+    }
+}

test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsHumanizerTests.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Threading.Tasks;
+using Moq;
+using Newtonsoft.Json.Linq;
+using NFluent;
+using WireMock.Handlers;
+using WireMock.Models;
+using WireMock.ResponseBuilders;
+using WireMock.Settings;
+using Xunit;
+
+namespace WireMock.Net.Tests.ResponseBuilders
+{
+    public class ResponseWithHandlebarsHumanizerTests
+    {
+        private const string ClientIp = "::1";
+
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
+        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+
+        public ResponseWithHandlebarsHumanizerTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponseAsync_Handlebars_Humanizer()
+        {
+            // Assign
+            var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
+
+            var responseBuilder = Response.Create()
+                .WithBodyAsJson(new
+                {
+                    DateTime = string.Format("{{{{[Humanizer.Humanize] \"{0}\" }}}}", DateTime.UtcNow.AddHours(-30).ToString("O"))
+                })
+                .WithTransformer();
+
+            // Act
+            var response = await responseBuilder.ProvideResponseAsync(request, _settings);
+
+            // Assert
+            JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
+            Check.That(j["DateTime"].Value<string>()).IsEqualTo("yesterday");
+        }
+    }
+}

test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsRegexTests.cs

@@ -65,25 +65,6 @@ namespace WireMock.Net.Tests.ResponseBuilders
             Check.That(response.Message.BodyData.BodyAsString).Equals("");
         }
 
-        [Fact]
-        public async Task Response_ProvideResponseAsync_Handlebars_RegexMatch_NoMatch_WithDefaultValue()
-        {
-            // Assign
-            var body = new BodyData { BodyAsString = "abc", DetectedBodyType = BodyType.String };
-
-            var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
-
-            var responseBuilder = Response.Create()
-                .WithBody("{{Regex.Match request.body \"^?0$\" \"d\"}}")
-                .WithTransformer();
-
-            // Act
-            var response = await responseBuilder.ProvideResponseAsync(request, _settings);
-
-            // assert
-            Check.That(response.Message.BodyData.BodyAsString).Equals("d");
-        }
-
         [Fact]
         public async Task Response_ProvideResponseAsync_Handlebars_RegexMatch2()
         {
@@ -122,25 +103,6 @@ namespace WireMock.Net.Tests.ResponseBuilders
             Check.That(response.Message.BodyData.BodyAsString).Equals("");
         }
 
-        [Fact]
-        public async Task Response_ProvideResponseAsync_Handlebars_RegexMatch2_NoMatch_WithDefaultValue()
-        {
-            // Assign
-            var body = new BodyData { BodyAsString = "{{\\test", DetectedBodyType = BodyType.String };
-
-            var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
-
-            var responseBuilder = Response.Create()
-                .WithBody("{{#Regex.Match request.body \"^(?<proto>\\w+)://[^/]+?(?<port>\\d+)/?\" \"x\"}}{{this}}{{/Regex.Match}}")
-                .WithTransformer();
-
-            // Act
-            var response = await responseBuilder.ProvideResponseAsync(request, _settings);
-
-            // assert
-            Check.That(response.Message.BodyData.BodyAsString).Equals("x");
-        }
-
         [Fact]
         public void Response_ProvideResponseAsync_Handlebars_RegexMatch2_Throws()
         {

test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsXPathTests.cs

@@ -9,6 +9,7 @@ using WireMock.Util;
 using Xunit;
 using Moq;
 using WireMock.Handlers;
+using FluentAssertions;
 #if !NETSTANDARD1_3
 using Wmhelp.XPath2;
 #endif
@@ -119,6 +120,62 @@ namespace WireMock.Net.Tests.ResponseBuilders
             Check.That(nodes.Count + 1).IsEqualTo(3);
         }
 
+        [Fact]
+        public async Task Response_ProvideResponse_Handlebars_XPath_SelectSingleNode_Request_SoapXML_BodyAsString()
+        {
+            // Assign
+            string soap = @"
+<soapenv:Envelope xmlns:soapenv=""http://schemas.xmlsoap.org/soap/envelope/"" xmlns:ns=""http://www.Test.nl/XMLHeader/10"" xmlns:req=""http://www.Test.nl/Betalen/COU/Services/RdplDbTknLystByOvkLyst/8/Req"">
+   <soapenv:Header>
+      <ns:TestHeader>
+         <ns:HeaderVersion>10</ns:HeaderVersion>
+         <ns:MessageId>MsgId10</ns:MessageId>
+         <ns:ServiceRequestorDomain>Betalen</ns:ServiceRequestorDomain>
+         <ns:ServiceRequestorId>CRM</ns:ServiceRequestorId>
+         <ns:ServiceProviderDomain>COU</ns:ServiceProviderDomain>
+         <ns:ServiceId>RdplDbTknLystByOvkLyst</ns:ServiceId>
+         <ns:ServiceVersion>8</ns:ServiceVersion>
+         <ns:FaultIndication>N</ns:FaultIndication>
+         <ns:MessageTimestamp>?</ns:MessageTimestamp>
+      </ns:TestHeader>
+   </soapenv:Header>
+   <soapenv:Body>
+      <req:RdplDbTknLystByOvkLyst_REQ>
+         <req:AanleveraarCode>CRM</req:AanleveraarCode>
+         <!--Optional:-->
+         <req:AanleveraarDetail>CRMi</req:AanleveraarDetail>
+         <req:BerichtId>BerId</req:BerichtId>
+         <req:BerichtType>RdplDbTknLystByOvkLyst</req:BerichtType>
+         <!--Optional:-->
+         <req:OpgenomenBedragenGewenstIndicatie>N</req:OpgenomenBedragenGewenstIndicatie>
+         <req:TokenIdLijst>
+            <!--1 to 10 repetitions:-->
+            <req:TokenId>0000083256</req:TokenId>
+            <req:TokenId>0000083259</req:TokenId>
+         </req:TokenIdLijst>
+      </req:RdplDbTknLystByOvkLyst_REQ>
+   </soapenv:Body>
+</soapenv:Envelope>";
+            var body = new BodyData
+            {
+                BodyAsString = soap,
+                DetectedBodyType = BodyType.String
+            };
+
+            var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
+
+            var responseBuilder = Response.Create()
+                .WithHeader("Content-Type", "application/xml")
+                .WithBody("<response>{{XPath.SelectSingleNode request.body \"//*[local-name()='TokenIdLijst']\"}}</response>")
+                .WithTransformer();
+
+            // Act
+            var response = await responseBuilder.ProvideResponseAsync(request, _settings);
+
+            // Assert
+            response.Message.BodyData.BodyAsString.Should().Contain("TokenIdLijst").And.Contain("0000083256").And.Contain("0000083259");
+        }
+
         [Fact]
         public async Task Response_ProvideResponse_Handlebars_XPath_Evaluate_Request_BodyAsString()
         {

test/WireMock.Net.Tests/Serialization/MappingConverterTests.cs

@@ -24,31 +24,34 @@ namespace WireMock.Net.Tests.Serialization
         }
 
         [Fact]
-        public void ToMappingModel()
+        public void ToMappingModel_With_SingleWebHook()
         {
             // Assign
             var request = Request.Create();
             var response = Response.Create();
-            var webhook = new Webhook
+            var webhooks = new IWebhook[]
             {
-                Request = new WebhookRequest
+                new Webhook
                 {
-                    Url = "https://test.com",
-                    Headers = new Dictionary<string, WireMockList<string>>
+                    Request = new WebhookRequest
                     {
-                        { "Single", new WireMockList<string>("x") },
-                        { "Multi", new WireMockList<string>("a", "b") }
-                    },
-                    Method = "post",
-                    BodyData = new BodyData
-                    {
-                        BodyAsString = "b",
-                        DetectedBodyType = BodyType.String,
-                        DetectedBodyTypeFromContentType = BodyType.String
+                        Url = "https://test.com",
+                        Headers = new Dictionary<string, WireMockList<string>>
+                        {
+                            { "Single", new WireMockList<string>("x") },
+                            { "Multi", new WireMockList<string>("a", "b") }
+                        },
+                        Method = "post",
+                        BodyData = new BodyData
+                        {
+                            BodyAsString = "b",
+                            DetectedBodyType = BodyType.String,
+                            DetectedBodyTypeFromContentType = BodyType.String
+                        }
                     }
                 }
             };
-            var mapping = new Mapping(Guid.NewGuid(), "", null, _settings, request, response, 0, null, null, null, null, webhook);
+            var mapping = new Mapping(Guid.NewGuid(), "", null, _settings, request, response, 0, null, null, null, null, webhooks);
 
             // Act
             var model = _sut.ToMappingModel(mapping);
@@ -61,6 +64,8 @@ namespace WireMock.Net.Tests.Serialization
             model.Response.UseTransformer.Should().BeNull();
             model.Response.Headers.Should().BeNull();
 
+            model.Webhooks.Should().BeNull();
+
             model.Webhook.Request.Method.Should().Be("post");
             model.Webhook.Request.Url.Should().Be("https://test.com");
             model.Webhook.Request.Headers.Should().HaveCount(2);
@@ -68,6 +73,80 @@ namespace WireMock.Net.Tests.Serialization
             model.Webhook.Request.BodyAsJson.Should().BeNull();
         }
 
+        [Fact]
+        public void ToMappingModel_With_MultipleWebHooks()
+        {
+            // Assign
+            var request = Request.Create();
+            var response = Response.Create();
+            var webhooks = new IWebhook[]
+            {
+                new Webhook
+                {
+                    Request = new WebhookRequest
+                    {
+                        Url = "https://test1.com",
+                        Headers = new Dictionary<string, WireMockList<string>>
+                        {
+                            { "One", new WireMockList<string>("x") }
+                        },
+                        Method = "post",
+                        BodyData = new BodyData
+                        {
+                            BodyAsString = "1",
+                            DetectedBodyType = BodyType.String,
+                            DetectedBodyTypeFromContentType = BodyType.String
+                        }
+                    }
+                },
+
+                new Webhook
+                {
+                    Request = new WebhookRequest
+                    {
+                        Url = "https://test2.com",
+                        Headers = new Dictionary<string, WireMockList<string>>
+                        {
+                            { "First", new WireMockList<string>("x") },
+                            { "Second", new WireMockList<string>("a", "b") }
+                        },
+                        Method = "post",
+                        BodyData = new BodyData
+                        {
+                            BodyAsString = "2",
+                            DetectedBodyType = BodyType.String,
+                            DetectedBodyTypeFromContentType = BodyType.String
+                        }
+                    }
+                }
+            };
+            var mapping = new Mapping(Guid.NewGuid(), "", null, _settings, request, response, 0, null, null, null, null, webhooks
+);
+
+            // Act
+            var model = _sut.ToMappingModel(mapping);
+
+            // Assert
+            model.Should().NotBeNull();
+            model.Priority.Should().BeNull();
+
+            model.Response.BodyAsJsonIndented.Should().BeNull();
+            model.Response.UseTransformer.Should().BeNull();
+            model.Response.Headers.Should().BeNull();
+
+            model.Webhook.Should().BeNull();
+
+            model.Webhooks[0].Request.Method.Should().Be("post");
+            model.Webhooks[0].Request.Url.Should().Be("https://test1.com");
+            model.Webhooks[0].Request.Headers.Should().HaveCount(1);
+            model.Webhooks[0].Request.Body.Should().Be("1");
+
+            model.Webhooks[1].Request.Method.Should().Be("post");
+            model.Webhooks[1].Request.Url.Should().Be("https://test2.com");
+            model.Webhooks[1].Request.Headers.Should().HaveCount(2);
+            model.Webhooks[1].Request.Body.Should().Be("2");
+        }
+
         [Fact]
         public void ToMappingModel_WithPriority_ReturnsPriority()
         {

test/WireMock.Net.Tests/Serialization/MatcherModelMapperTests.cs

@@ -1,276 +1,276 @@
-using System;
-using FluentAssertions;
-using NFluent;
-using WireMock.Admin.Mappings;
-using WireMock.Matchers;
-using WireMock.Serialization;
-using WireMock.Settings;
-using Xunit;
-
-namespace WireMock.Net.Tests.Serialization
-{
-    public class MatcherModelMapperTests
-    {
-        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
-
-        private readonly MatcherMapper _sut;
-
-        public MatcherModelMapperTests()
-        {
-            _sut = new MatcherMapper(_settings);
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_CSharpCodeMatcher()
-        {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "CSharpCodeMatcher",
-                Patterns = new[] { "return it == \"x\";" }
-            };
-            var sut = new MatcherMapper(new WireMockServerSettings { AllowCSharpCodeMatcher = true });
-
-            // Act 1
-            var matcher1 = (ICSharpCodeMatcher)sut.Map(model);
-
-            // Assert 1
-            matcher1.Should().NotBeNull();
+using System;
+using FluentAssertions;
+using NFluent;
+using WireMock.Admin.Mappings;
+using WireMock.Matchers;
+using WireMock.Serialization;
+using WireMock.Settings;
+using Xunit;
+
+namespace WireMock.Net.Tests.Serialization
+{
+    public class MatcherModelMapperTests
+    {
+        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+
+        private readonly MatcherMapper _sut;
+
+        public MatcherModelMapperTests()
+        {
+            _sut = new MatcherMapper(_settings);
+        }
+
+        [Fact]
+        public void MatcherModelMapper_Map_CSharpCodeMatcher()
+        {
+            // Assign
+            var model = new MatcherModel
+            {
+                Name = "CSharpCodeMatcher",
+                Patterns = new[] { "return it == \"x\";" }
+            };
+            var sut = new MatcherMapper(new WireMockServerSettings { AllowCSharpCodeMatcher = true });
+
+            // Act 1
+            var matcher1 = (ICSharpCodeMatcher)sut.Map(model);
+
+            // Assert 1
+            matcher1.Should().NotBeNull();
             matcher1.IsMatch("x").Should().Be(1.0d);
 
             // Act 2
-            var matcher2 = (ICSharpCodeMatcher)sut.Map(model);
-
-            // Assert 2
-            matcher2.Should().NotBeNull();
-            matcher2.IsMatch("x").Should().Be(1.0d);
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_CSharpCodeMatcher_NotAllowed_ThrowsException()
-        {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "CSharpCodeMatcher",
-                Patterns = new[] { "x" }
-            };
-            var sut = new MatcherMapper(new WireMockServerSettings { AllowCSharpCodeMatcher = false });
-
-            // Act
-            Action action = () => sut.Map(model);
-
-            // Assert
-            action.Should().Throw<NotSupportedException>();
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_Null()
-        {
-            // Act
-            IMatcher matcher = _sut.Map((MatcherModel)null);
-
-            // Assert
-            Check.That(matcher).IsNull();
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_ExactMatcher_Pattern()
-        {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "ExactMatcher",
-                Patterns = new[] { "x" }
-            };
-
-            // Act
-            var matcher = (ExactMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.GetPatterns().Should().ContainSingle("x");
-            matcher.ThrowException.Should().BeFalse();
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_ExactMatcher_Patterns()
-        {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "ExactMatcher",
-                Patterns = new[] { "x", "y" }
-            };
-
-            // Act
-            var matcher = (ExactMatcher)_sut.Map(model);
-
-            // Assert
-            Check.That(matcher.GetPatterns()).ContainsExactly("x", "y");
-        }
-
-        [Theory]
-        [InlineData(nameof(LinqMatcher))]
-        [InlineData(nameof(ExactMatcher))]
-        [InlineData(nameof(ExactObjectMatcher))]
-        [InlineData(nameof(RegexMatcher))]
-        [InlineData(nameof(JsonMatcher))]
-        [InlineData(nameof(JsonPathMatcher))]
-        [InlineData(nameof(JmesPathMatcher))]
-        [InlineData(nameof(XPathMatcher))]
-        [InlineData(nameof(WildcardMatcher))]
-        [InlineData(nameof(ContentTypeMatcher))]
-        [InlineData(nameof(SimMetricsMatcher))]
-        public void MatcherModelMapper_Map_ThrowExceptionWhenMatcherFails_True(string name)
-        {
-            // Assign
-            var settings = new WireMockServerSettings
-            {
-                ThrowExceptionWhenMatcherFails = true
-            };
-            var sut = new MatcherMapper(settings);
-            var model = new MatcherModel
-            {
-                Name = name,
-                Patterns = new[] { "" }
-            };
-
-            // Act
-            var matcher = sut.Map(model);
-
-            // Assert
-            matcher.ThrowException.Should().BeTrue();
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_ExactObjectMatcher_ValidBase64StringPattern()
-        {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "ExactObjectMatcher",
-                Patterns = new object[] { "c3RlZg==" }
-            };
-
-            // Act
-            var matcher = (ExactObjectMatcher)_sut.Map(model);
-
-            // Assert
-            Check.That(matcher.ValueAsBytes).ContainsExactly(new byte[] { 115, 116, 101, 102 });
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_ExactObjectMatcher_InvalidBase64StringPattern()
-        {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "ExactObjectMatcher",
-                Patterns = new object[] { "_" }
-            };
-
-            // Act & Assert
-            Check.ThatCode(() => _sut.Map(model)).Throws<ArgumentException>();
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_RegexMatcher()
-        {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "RegexMatcher",
-                Patterns = new[] { "x", "y" },
-                IgnoreCase = true
-            };
-
-            // Act
-            var matcher = (RegexMatcher)_sut.Map(model);
-
-            // Assert
-            Check.That(matcher.GetPatterns()).ContainsExactly("x", "y");
-            Check.That(matcher.IsMatch("X")).IsEqualTo(0.5d);
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_WildcardMatcher()
-        {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "WildcardMatcher",
-                Patterns = new[] { "x", "y" },
-                IgnoreCase = true
-            };
-
-            // Act
-            var matcher = (WildcardMatcher)_sut.Map(model);
-
-            // Assert
-            Check.That(matcher.GetPatterns()).ContainsExactly("x", "y");
-            Check.That(matcher.IsMatch("X")).IsEqualTo(0.5d);
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_SimMetricsMatcher()
-        {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "SimMetricsMatcher",
-                Pattern = "x"
-            };
-
-            // Act
-            var matcher = (SimMetricsMatcher)_sut.Map(model);
-
-            // Assert
-            Check.That(matcher.GetPatterns()).ContainsExactly("x");
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_SimMetricsMatcher_BlockDistance()
-        {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "SimMetricsMatcher.BlockDistance",
-                Pattern = "x"
-            };
-
-            // Act
-            var matcher = (SimMetricsMatcher)_sut.Map(model);
-
-            // Assert
-            Check.That(matcher.GetPatterns()).ContainsExactly("x");
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_SimMetricsMatcher_Throws1()
-        {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "error",
-                Pattern = "x"
-            };
-
-            // Act
-            Check.ThatCode(() => _sut.Map(model)).Throws<NotSupportedException>();
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_SimMetricsMatcher_Throws2()
-        {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "SimMetricsMatcher.error",
-                Pattern = "x"
-            };
-
-            // Act
-            Check.ThatCode(() => _sut.Map(model)).Throws<NotSupportedException>();
-        }
-    }
+            var matcher2 = (ICSharpCodeMatcher)sut.Map(model);
+
+            // Assert 2
+            matcher2.Should().NotBeNull();
+            matcher2.IsMatch("x").Should().Be(1.0d);
+        }
+
+        [Fact]
+        public void MatcherModelMapper_Map_CSharpCodeMatcher_NotAllowed_ThrowsException()
+        {
+            // Assign
+            var model = new MatcherModel
+            {
+                Name = "CSharpCodeMatcher",
+                Patterns = new[] { "x" }
+            };
+            var sut = new MatcherMapper(new WireMockServerSettings { AllowCSharpCodeMatcher = false });
+
+            // Act
+            Action action = () => sut.Map(model);
+
+            // Assert
+            action.Should().Throw<NotSupportedException>();
+        }
+
+        [Fact]
+        public void MatcherModelMapper_Map_Null()
+        {
+            // Act
+            IMatcher matcher = _sut.Map((MatcherModel)null);
+
+            // Assert
+            Check.That(matcher).IsNull();
+        }
+
+        [Fact]
+        public void MatcherModelMapper_Map_ExactMatcher_Pattern()
+        {
+            // Assign
+            var model = new MatcherModel
+            {
+                Name = "ExactMatcher",
+                Patterns = new[] { "x" }
+            };
+
+            // Act
+            var matcher = (ExactMatcher)_sut.Map(model);
+
+            // Assert
+            matcher.GetPatterns().Should().ContainSingle("x");
+            matcher.ThrowException.Should().BeFalse();
+        }
+
+        [Fact]
+        public void MatcherModelMapper_Map_ExactMatcher_Patterns()
+        {
+            // Assign
+            var model = new MatcherModel
+            {
+                Name = "ExactMatcher",
+                Patterns = new[] { "x", "y" }
+            };
+
+            // Act
+            var matcher = (ExactMatcher)_sut.Map(model);
+
+            // Assert
+            Check.That(matcher.GetPatterns()).ContainsExactly("x", "y");
+        }
+
+        [Theory]
+        [InlineData(nameof(LinqMatcher))]
+        [InlineData(nameof(ExactMatcher))]
+        [InlineData(nameof(ExactObjectMatcher))]
+        [InlineData(nameof(RegexMatcher))]
+        [InlineData(nameof(JsonMatcher))]
+        [InlineData(nameof(JsonPathMatcher))]
+        [InlineData(nameof(JmesPathMatcher))]
+        [InlineData(nameof(XPathMatcher))]
+        [InlineData(nameof(WildcardMatcher))]
+        [InlineData(nameof(ContentTypeMatcher))]
+        [InlineData(nameof(SimMetricsMatcher))]
+        public void MatcherModelMapper_Map_ThrowExceptionWhenMatcherFails_True(string name)
+        {
+            // Assign
+            var settings = new WireMockServerSettings
+            {
+                ThrowExceptionWhenMatcherFails = true
+            };
+            var sut = new MatcherMapper(settings);
+            var model = new MatcherModel
+            {
+                Name = name,
+                Patterns = new[] { "" }
+            };
+
+            // Act
+            var matcher = sut.Map(model);
+
+            // Assert
+            matcher.ThrowException.Should().BeTrue();
+        }
+
+        [Fact]
+        public void MatcherModelMapper_Map_ExactObjectMatcher_ValidBase64StringPattern()
+        {
+            // Assign
+            var model = new MatcherModel
+            {
+                Name = "ExactObjectMatcher",
+                Patterns = new object[] { "c3RlZg==" }
+            };
+
+            // Act
+            var matcher = (ExactObjectMatcher)_sut.Map(model);
+
+            // Assert
+            Check.That(matcher.ValueAsBytes).ContainsExactly(new byte[] { 115, 116, 101, 102 });
+        }
+
+        [Fact]
+        public void MatcherModelMapper_Map_ExactObjectMatcher_InvalidBase64StringPattern()
+        {
+            // Assign
+            var model = new MatcherModel
+            {
+                Name = "ExactObjectMatcher",
+                Patterns = new object[] { "_" }
+            };
+
+            // Act & Assert
+            Check.ThatCode(() => _sut.Map(model)).Throws<ArgumentException>();
+        }
+
+        [Fact]
+        public void MatcherModelMapper_Map_RegexMatcher()
+        {
+            // Assign
+            var model = new MatcherModel
+            {
+                Name = "RegexMatcher",
+                Patterns = new[] { "x", "y" },
+                IgnoreCase = true
+            };
+
+            // Act
+            var matcher = (RegexMatcher)_sut.Map(model);
+
+            // Assert
+            Check.That(matcher.GetPatterns()).ContainsExactly("x", "y");
+            Check.That(matcher.IsMatch("X")).IsEqualTo(0.5d);
+        }
+
+        [Fact]
+        public void MatcherModelMapper_Map_WildcardMatcher()
+        {
+            // Assign
+            var model = new MatcherModel
+            {
+                Name = "WildcardMatcher",
+                Patterns = new[] { "x", "y" },
+                IgnoreCase = true
+            };
+
+            // Act
+            var matcher = (WildcardMatcher)_sut.Map(model);
+
+            // Assert
+            Check.That(matcher.GetPatterns()).ContainsExactly("x", "y");
+            Check.That(matcher.IsMatch("X")).IsEqualTo(0.5d);
+        }
+
+        [Fact]
+        public void MatcherModelMapper_Map_SimMetricsMatcher()
+        {
+            // Assign
+            var model = new MatcherModel
+            {
+                Name = "SimMetricsMatcher",
+                Pattern = "x"
+            };
+
+            // Act
+            var matcher = (SimMetricsMatcher)_sut.Map(model);
+
+            // Assert
+            Check.That(matcher.GetPatterns()).ContainsExactly("x");
+        }
+
+        [Fact]
+        public void MatcherModelMapper_Map_SimMetricsMatcher_BlockDistance()
+        {
+            // Assign
+            var model = new MatcherModel
+            {
+                Name = "SimMetricsMatcher.BlockDistance",
+                Pattern = "x"
+            };
+
+            // Act
+            var matcher = (SimMetricsMatcher)_sut.Map(model);
+
+            // Assert
+            Check.That(matcher.GetPatterns()).ContainsExactly("x");
+        }
+
+        [Fact]
+        public void MatcherModelMapper_Map_SimMetricsMatcher_Throws1()
+        {
+            // Assign
+            var model = new MatcherModel
+            {
+                Name = "error",
+                Pattern = "x"
+            };
+
+            // Act
+            Check.ThatCode(() => _sut.Map(model)).Throws<NotSupportedException>();
+        }
+
+        [Fact]
+        public void MatcherModelMapper_Map_SimMetricsMatcher_Throws2()
+        {
+            // Assign
+            var model = new MatcherModel
+            {
+                Name = "SimMetricsMatcher.error",
+                Pattern = "x"
+            };
+
+            // Act
+            Check.ThatCode(() => _sut.Map(model)).Throws<NotSupportedException>();
+        }
+    }
 }

test/WireMock.Net.Tests/WireMockServer.Admin.cs

@@ -422,7 +422,7 @@ namespace WireMock.Net.Tests
         }
 
         [Fact]
-        public async void WireMockServer_Admin_DeleteMappings()
+        public async Task WireMockServer_Admin_DeleteMappings()
         {
             // Arrange
             var server = WireMockServer.Start(new WireMockServerSettings

test/WireMock.Net.Tests/WireMockServer.WebhookTests.cs

@@ -16,6 +16,74 @@ namespace WireMock.Net.Tests
 {
     public class WireMockServerWebhookTests
     {
+        [Fact]
+        public async Task WireMockServer_WithWebhooks_Should_Send_Message_To_Webhooks()
+        {
+            // Assign
+            var serverReceivingTheWebhook1 = WireMockServer.Start();
+            serverReceivingTheWebhook1.Given(Request.Create().UsingPost()).RespondWith(Response.Create().WithStatusCode(200));
+
+            var serverReceivingTheWebhook2 = WireMockServer.Start();
+            serverReceivingTheWebhook2.Given(Request.Create().UsingPost()).RespondWith(Response.Create().WithStatusCode(200));
+
+            var webhook1 = new Webhook
+            {
+                Request = new WebhookRequest
+                {
+                    Url = serverReceivingTheWebhook1.Urls[0],
+                    Method = "post",
+                    BodyData = new BodyData
+                    {
+                        BodyAsString = "1",
+                        DetectedBodyType = BodyType.String,
+                        DetectedBodyTypeFromContentType = BodyType.String
+                    }
+                }
+            };
+
+            var webhook2 = new Webhook
+            {
+                Request = new WebhookRequest
+                {
+                    Url = serverReceivingTheWebhook2.Urls[0],
+                    Method = "post",
+                    BodyData = new BodyData
+                    {
+                        BodyAsString = "2",
+                        DetectedBodyType = BodyType.String,
+                        DetectedBodyTypeFromContentType = BodyType.String
+                    }
+                }
+            };
+
+            // Act
+            var server = WireMockServer.Start();
+            server.Given(Request.Create().UsingPost())
+                .WithWebhook(webhook1, webhook2)
+                .RespondWith(Response.Create().WithBody("a-response"));
+
+            var request = new HttpRequestMessage
+            {
+                Method = HttpMethod.Post,
+                RequestUri = new Uri($"{server.Urls[0]}/TST"),
+                Content = new StringContent("test")
+            };
+
+            // Assert
+            var response = await new HttpClient().SendAsync(request);
+            string content = await response.Content.ReadAsStringAsync();
+
+            response.StatusCode.Should().Be(HttpStatusCode.OK);
+            content.Should().Be("a-response");
+
+            serverReceivingTheWebhook1.LogEntries.Should().HaveCount(1);
+            serverReceivingTheWebhook2.LogEntries.Should().HaveCount(1);
+
+            server.Dispose();
+            serverReceivingTheWebhook1.Dispose();
+            serverReceivingTheWebhook2.Dispose();
+        }
+
         [Fact]
         public async Task WireMockServer_WithWebhook_Should_Send_Message_To_Webhook()
         {