1.3.1

* Adding netcoreapp3.0 and netcoreapp3.1 as a target framework

* Expanding NETSTANDARD check to include ASP.NET Core targets

* End of life netcoreapp3.0 changes and using NETCOREAPP3_1 instead of USE_ASPNETCORE where possible

.github/ISSUE_TEMPLATE/feature_request.md

@@ -16,7 +16,7 @@ A clear and concise description of what you want to happen.
 **Describe alternatives you've considered**
 A clear and concise description of any alternative solutions or features you've considered.
 
-**Is your feature request supported by [Handlebarsjs](https://handlebarsjs.com/)? Please provide details.**
+**Is your feature request supported by [WireMock (java version)](https://www.wiremock.org)? Please provide details.**
 Provide relevant information if requested feature is supported in [Handlebarsjs](https://handlebarsjs.com/) but is missing in our implementation.
 
 **Additional context**

CHANGELOG.md

@@ -1,3 +1,27 @@
+# 1.3.1 (30 September 2020)
+- [#509](https://github.com/WireMock-Net/WireMock.Net/pull/509) - Adding netcoreapp3.1 as a target framework [feature] contributed by [APIWT](https://github.com/APIWT)
+
+# 1.3.0 (29 September 2020)
+- [#508](https://github.com/WireMock-Net/WireMock.Net/pull/508) - Fix vulnerability in NuGet dependencies contributed by [StefH](https://github.com/StefH)
+- [#327](https://github.com/WireMock-Net/WireMock.Net/issues/327) - Index must be within the bounds of the List - Bug [bug]
+- [#507](https://github.com/WireMock-Net/WireMock.Net/issues/507) - Fix vulnerability found in Microsoft.AspNetCore dependency [feature]
+
+# 1.2.18 (13 August 2020)
+- [#496](https://github.com/WireMock-Net/WireMock.Net/pull/496) - Add setting to handle requests synchronously [feature] contributed by [StefH](https://github.com/StefH)
+- [#500](https://github.com/WireMock-Net/WireMock.Net/pull/500) - Add ThrowExceptionWhenMatcherFails option to all Matchers [feature] contributed by [StefH](https://github.com/StefH)
+- [#478](https://github.com/WireMock-Net/WireMock.Net/issues/478) - Sometimes returns status code 0 in unit tests with xunit test fixture (flaky test) [bug]
+
+# 1.2.17 (01 August 2020)
+- [#495](https://github.com/WireMock-Net/WireMock.Net/pull/495) - Scenario : stay on current state for a number of times contributed by [StefH](https://github.com/StefH)
+- [#494](https://github.com/WireMock-Net/WireMock.Net/issues/494) - Stay in Current State for specified number of requests [feature]
+
+# 1.2.16 (27 July 2020)
+- [#492](https://github.com/WireMock-Net/WireMock.Net/pull/492) - Mark FluentMockServer, FluentMockServerSettings, BlacklistedHeaders and BlacklistedCookies as obsolete [feature] contributed by [StefH](https://github.com/StefH)
+- [#489](https://github.com/WireMock-Net/WireMock.Net/issues/489) - Change "blacklist" and "whitelist" terms [feature]
+
+# 1.2.15 (19 July 2020)
+- [#485](https://github.com/WireMock-Net/WireMock.Net/pull/485) - Add fluent assertions for headers [test] contributed by [akamud](https://github.com/akamud)
+
 # 1.2.14 (09 July 2020)
 - [#479](https://github.com/WireMock-Net/WireMock.Net/pull/479) - An OpenApi (swagger) parser to generate MappingModel or mapping.json file [feature] contributed by [StefH](https://github.com/StefH)
 - [#482](https://github.com/WireMock-Net/WireMock.Net/pull/482) - Add PartialMatch to logging / logentries [feature] contributed by [StefH](https://github.com/StefH)

Directory.Build.props

@@ -4,7 +4,7 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <VersionPrefix>1.2.14</VersionPrefix>
+    <VersionPrefix>1.3.1</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.exe --output CHANGELOG.md --skip-empty-releases --exclude-labels question invalid doc --version 1.2.14
+GitHubReleaseNotes.exe --output CHANGELOG.md --skip-empty-releases --exclude-labels question invalid doc --version 1.3.1

README.md

@@ -29,10 +29,10 @@ A C# .NET version based on [mock4net](https://github.com/alexvictoor/mock4net) w
 
 | | Official | Preview |
 | - | - | - |
-|   **WireMock.Net** | [![NuGet Badge WireMock.Net](https://buildstats.info/nuget/WireMock.Net)](https://www.nuget.org/packages/WireMock.Net) |  [![MyGet Badge WireMock.Net](https://buildstats.info/myget/wiremock-net/WireMock.Net)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net)
+|   **WireMock.Net** | [![NuGet Badge WireMock.Net](https://buildstats.info/nuget/WireMock.Net)](https://www.nuget.org/packages/WireMock.Net) |  [![MyGet Badge WireMock.Net](https://buildstats.info/myget/wiremock-net/WireMock.Net?includePreReleases=true)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net)
-|   **WireMock.Net.StandAlone** | [![NuGet Badge WireMock.Net](https://buildstats.info/nuget/WireMock.Net.StandAlone)](https://www.nuget.org/packages/WireMock.Net.StandAlone) |  [![MyGet Badge WireMock.Net.StandAlone](https://buildstats.info/myget/wiremock-net/WireMock.Net.StandAlone)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net.StandAlone)
+|   **WireMock.Net.StandAlone** | [![NuGet Badge WireMock.Net](https://buildstats.info/nuget/WireMock.Net.StandAlone)](https://www.nuget.org/packages/WireMock.Net.StandAlone) |  [![MyGet Badge WireMock.Net.StandAlone](https://buildstats.info/myget/wiremock-net/WireMock.Net.StandAlone?includePreReleases=true)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net.StandAlone)
-|   **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)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net.FluentAssertions)
+|   **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)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net.RestClient)
+|   **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)
 
 ## 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

@@ -63,13 +63,11 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WireMock.Net.Console.NETCor
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WireMock.Net.Console.RequestLogTest", "examples\WireMock.Net.Console.RequestLogTest\WireMock.Net.Console.RequestLogTest.csproj", "{A9D039B9-7509-4CF1-9EFD-87EB82998575}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WireMock.Net.Client.Net472", "examples\WireMock.Net.Client.Net472\WireMock.Net.Client.Net472.csproj", "{02082E34-DEF2-47D0-AF0B-3326FAA908CE}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WireMock.Net.OpenApiParser", "src\WireMock.Net.OpenApiParser\WireMock.Net.OpenApiParser.csproj", "{D3804228-91F4-4502-9595-39584E5AADAD}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WireMock.Net.OpenApiParser.ConsoleApp", "examples\WireMock.Net.OpenApiParser.ConsoleApp\WireMock.Net.OpenApiParser.ConsoleApp.csproj", "{5C09FB93-1535-4F92-AF26-21E8A061EE4A}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WireMock.Net.FluentAssertions", "src\WireMock.Net.FluentAssertions\WireMock.Net.FluentAssertions.csproj", "{2C837E73-5EDD-43AD-B65A-194E4A3AD9FE}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WireMock.Net.FluentAssertions", "src\WireMock.Net.FluentAssertions\WireMock.Net.FluentAssertions.csproj", "{B6269AAC-170A-4346-8B9A-579DED3D9A95}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -157,10 +155,6 @@ Global
 		{A9D039B9-7509-4CF1-9EFD-87EB82998575}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{A9D039B9-7509-4CF1-9EFD-87EB82998575}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{A9D039B9-7509-4CF1-9EFD-87EB82998575}.Release|Any CPU.Build.0 = Release|Any CPU
-		{02082E34-DEF2-47D0-AF0B-3326FAA908CE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{02082E34-DEF2-47D0-AF0B-3326FAA908CE}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{02082E34-DEF2-47D0-AF0B-3326FAA908CE}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{02082E34-DEF2-47D0-AF0B-3326FAA908CE}.Release|Any CPU.Build.0 = Release|Any CPU
 		{D3804228-91F4-4502-9595-39584E5AADAD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{D3804228-91F4-4502-9595-39584E5AADAD}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{D3804228-91F4-4502-9595-39584E5AADAD}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -169,10 +163,10 @@ Global
 		{5C09FB93-1535-4F92-AF26-21E8A061EE4A}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{5C09FB93-1535-4F92-AF26-21E8A061EE4A}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{5C09FB93-1535-4F92-AF26-21E8A061EE4A}.Release|Any CPU.Build.0 = Release|Any CPU
-		{2C837E73-5EDD-43AD-B65A-194E4A3AD9FE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B6269AAC-170A-4346-8B9A-579DED3D9A95}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{2C837E73-5EDD-43AD-B65A-194E4A3AD9FE}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B6269AAC-170A-4346-8B9A-579DED3D9A95}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{2C837E73-5EDD-43AD-B65A-194E4A3AD9FE}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B6269AAC-170A-4346-8B9A-579DED3D9A95}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{2C837E73-5EDD-43AD-B65A-194E4A3AD9FE}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B6269AAC-170A-4346-8B9A-579DED3D9A95}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -198,10 +192,9 @@ Global
 		{668F689E-57B4-422E-8846-C0FF643CA268} = {985E0ADB-D4B4-473A-AA40-567E279B7946}
 		{83645809-9E01-4E81-8733-BA9497554ABF} = {985E0ADB-D4B4-473A-AA40-567E279B7946}
 		{A9D039B9-7509-4CF1-9EFD-87EB82998575} = {985E0ADB-D4B4-473A-AA40-567E279B7946}
-		{02082E34-DEF2-47D0-AF0B-3326FAA908CE} = {985E0ADB-D4B4-473A-AA40-567E279B7946}
 		{D3804228-91F4-4502-9595-39584E5AADAD} = {8F890C6F-9ACC-438D-928A-AD61CDA862F2}
 		{5C09FB93-1535-4F92-AF26-21E8A061EE4A} = {985E0ADB-D4B4-473A-AA40-567E279B7946}
-		{2C837E73-5EDD-43AD-B65A-194E4A3AD9FE} = {8F890C6F-9ACC-438D-928A-AD61CDA862F2}
+		{B6269AAC-170A-4346-8B9A-579DED3D9A95} = {8F890C6F-9ACC-438D-928A-AD61CDA862F2}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {DC539027-9852-430C-B19F-FD035D018458}

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

@@ -133,7 +133,7 @@ namespace WireMock.Net.ConsoleApplication
                     .WithPath("/proxy-execute-keep-alive")
                 )
                 .RespondWith(Response.Create()
-                    .WithProxy(new ProxyAndRecordSettings { Url = "http://localhost:9999", BlackListedHeaders = new[] { "Keep-Alive" } })
+                    .WithProxy(new ProxyAndRecordSettings { Url = "http://localhost:9999", ExcludedHeaders = new[] { "Keep-Alive" } })
                     .WithHeader("Keep-Alive-Test", "stef")
                 );
 

examples/WireMock.Net.Console.Proxy.NETCoreApp2/Program.cs

@@ -28,7 +28,7 @@ namespace WireMock.Net.Console.Proxy.NETCoreApp2
                     //ClientX509Certificate2ThumbprintOrSubjectName = "www.yourclientcertname.com OR yourcertificatethumbprint (only if the service you're proxying to requires it)",
                     SaveMapping = true,
                     SaveMappingToFile = false,
-                    BlackListedHeaders = new[] { "dnt", "Content-Length" }
+                    ExcludedHeaders = new[] { "dnt", "Content-Length" }
                 }
             });
 

examples/WireMock.Net.Console.Proxy.Net452/Program.cs

@@ -22,7 +22,7 @@ namespace WireMock.Net.Console.Proxy.Net452
                     //ClientX509Certificate2ThumbprintOrSubjectName = "www.yourclientcertname.com OR yourcertificatethumbprint (only if the service you're proxying to requires it)",
                     SaveMapping = true,
                     SaveMappingToFile = false,
-                    BlackListedHeaders = new[] { "dnt", "Content-Length" }
+                    ExcludedHeaders = new[] { "dnt", "Content-Length" }
                 }
             });
 

examples/WireMock.Net.Console.Record.NETCoreApp/Program.cs

@@ -19,7 +19,7 @@ namespace WireMock.Net.Console.Proxy.NETCoreApp
                     //ClientX509Certificate2ThumbprintOrSubjectName = "www.yourclientcertname.com OR yourcertificatethumbprint (only if the service you're proxying to requires it)",
                     SaveMapping = true,
                     SaveMappingToFile = false,
-                    BlackListedHeaders = new [] { "dnt", "Content-Length" }
+                    ExcludedHeaders = new [] { "dnt", "Content-Length" }
                 }
             });
 

examples/WireMock.Net.Console.RequestLogTest/Program.cs

@@ -14,7 +14,7 @@ namespace WireMock.Net.Console.RequestLogTest
     {
         static async Task Main(string[] args)
         {
-            var server = StandAloneApp.Start(new FluentMockServerSettings
+            var server = StandAloneApp.Start(new WireMockServerSettings
             {
                 Port = 19019,
                 StartAdminInterface = true,

examples/WireMock.Net.Service/WireMock.Net.Service.csproj

@@ -80,8 +80,8 @@
     <Reference Include="System.Data" />
     <Reference Include="System.Net.Http" />
     <Reference Include="System.Xml" />
-    <Reference Include="XPath2, Version=1.0.9.0, Culture=neutral, PublicKeyToken=463c6d7fb740c7e5, processorArchitecture=MSIL">
+    <Reference Include="XPath2, Version=1.1.0.0, Culture=neutral, PublicKeyToken=463c6d7fb740c7e5, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\XPath2.1.0.10\lib\net40\XPath2.dll</HintPath>
+      <HintPath>..\..\packages\XPath2.1.1.0\lib\net40\XPath2.dll</HintPath>
     </Reference>
   </ItemGroup>
   <ItemGroup>

examples/WireMock.Net.Service/packages.config

@@ -13,5 +13,5 @@
   <package id="Owin" version="1.0" targetFramework="net452" />
   <package id="SimMetrics.Net" version="1.0.5" targetFramework="net452" />
   <package id="System.Net.Http" version="4.3.3" targetFramework="net452" />
-  <package id="XPath2" version="1.0.10" targetFramework="net452" />
+  <package id="XPath2" version="1.1.0" targetFramework="net452" />
 </packages>

examples/WireMock.Net.StandAlone.Net461/WireMock.Net.StandAlone.Net461.csproj

@@ -280,8 +280,8 @@
     </Reference>
     <Reference Include="System.Xml" />
     <Reference Include="System.Xml.Linq" />
-    <Reference Include="XPath2, Version=1.0.7.0, Culture=neutral, PublicKeyToken=463c6d7fb740c7e5, processorArchitecture=MSIL">
+    <Reference Include="XPath2, Version=1.1.0.0, Culture=neutral, PublicKeyToken=463c6d7fb740c7e5, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\XPath2.1.0.6.1\lib\net40\XPath2.dll</HintPath>
+      <HintPath>..\..\packages\XPath2.1.1.0\lib\net40\XPath2.dll</HintPath>
     </Reference>
   </ItemGroup>
   <ItemGroup>

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

@@ -78,5 +78,5 @@
   <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.Threading.Tasks.Extensions" version="4.5.1" targetFramework="net461" />
-  <package id="XPath2" version="1.0.6.1" targetFramework="net461" />
+  <package id="XPath2" version="1.1.0" targetFramework="net461" />
 </packages>

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

@@ -24,5 +24,10 @@
         /// Gets or sets a value indicating whether this <see cref="ScenarioStateModel"/> is finished.
         /// </summary>
         public bool Finished { get; set; }
+
+        /// <summary>
+        /// Gets or sets the state counter.
+        /// </summary>
+        public int Counter { get; set; }
     }
 }

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

@@ -26,8 +26,18 @@
         public int? MaxRequestLogCount { get; set; }
 
         /// <summary>
-        /// Gets or sets wether to allow a body for all HTTP methods.
+        /// Allow a Body for all HTTP Methods. (default set to false).
         /// </summary>
         public bool? AllowBodyForAllHttpMethods { get; set; }
+
+        /// <summary>
+        /// Handle all requests synchronously. (default set to false).
+        /// </summary>
+        public bool? HandleRequestsSynchronously { get; set; }
+
+        /// <summary>
+        /// Throw an exception when the Matcher fails because of invalid input. (default set to false).
+        /// </summary>
+        public bool? ThrowExceptionWhenMatcherFails { get; set; }
     }
 }

src/WireMock.Net.Abstractions/IResponseMessage.cs

@@ -45,7 +45,18 @@ namespace WireMock
         /// </summary>
         object StatusCode { get; }
 
-        //void AddHeader(string name, params string[] values);
+        /// <summary>
-        //void AddHeader(string name, string value);
+        /// Adds the header.
+        /// </summary>
+        /// <param name="name">The name.</param>
+        /// <param name="value">The value.</param>
+        void AddHeader(string name, string value);
+
+        /// <summary>
+        /// Adds the header.
+        /// </summary>
+        /// <param name="name">The name.</param>
+        /// <param name="values">The values.</param>
+        void AddHeader(string name, params string[] values);
     }
 }

src/WireMock.Net.Abstractions/Logging/ILogEntry.cs

@@ -3,78 +3,54 @@ using WireMock.Matchers.Request;
 
 namespace WireMock.Logging
 {
+    /// <summary>
+    /// ILogEntry
+    /// </summary>
     public interface ILogEntry
     {
         /// <summary>
         /// Gets the unique identifier.
         /// </summary>
-        /// <value>
-        /// The unique identifier.
-        /// </value>
         Guid Guid { get; }
 
         /// <summary>
         /// Gets the mapping unique identifier.
         /// </summary>
-        /// <value>
-        /// The mapping unique identifier.
-        /// </value>
         Guid? MappingGuid { get; }
 
         /// <summary>
         /// Gets the mapping unique title.
         /// </summary>
-        /// <value>
-        /// The mapping unique title.
-        /// </value>
         string MappingTitle { get; }
 
         /// <summary>
         /// Gets the partial mapping unique identifier.
         /// </summary>
-        /// <value>
-        /// The mapping unique identifier.
-        /// </value>
         Guid? PartialMappingGuid { get; }
 
         /// <summary>
         /// Gets the partial mapping unique title.
         /// </summary>
-        /// <value>
-        /// The mapping unique title.
-        /// </value>
         string PartialMappingTitle { get; }
 
         /// <summary>
         /// Gets the partial match result.
         /// </summary>
-        /// <value>
-        /// The request match result.
-        /// </value>
         IRequestMatchResult PartialMatchResult { get; }
 
         /// <summary>
         /// Gets the request match result.
         /// </summary>
-        /// <value>
-        /// The request match result.
-        /// </value>
         IRequestMatchResult RequestMatchResult { get; }
 
         /// <summary>
         /// Gets the request message.
         /// </summary>
-        /// <value>
-        /// The request message.
-        /// </value>
         IRequestMessage RequestMessage { get; }
 
         /// <summary>
         /// Gets the response message.
         /// </summary>
-        /// <value>
-        /// The response message.
-        /// </value>
         IResponseMessage ResponseMessage { get; }
     }
 }

src/WireMock.Net.Abstractions/Matchers/Request/MatchDetail.cs

@@ -2,10 +2,19 @@
 
 namespace WireMock.Matchers.Request
 {
+    /// <summary>
+    /// MatchDetail
+    /// </summary>
     public class MatchDetail
     {
+        /// <summary>
+        /// Gets or sets the type of the matcher.
+        /// </summary>
         public Type MatcherType { get; set; }
 
+        /// <summary>
+        /// Gets or sets the score between 0.0 and 1.0
+        /// </summary>
         public double Score { get; set; }
     }
 }

src/WireMock.Net.Abstractions/Server/IWireMockServer.cs

@@ -27,9 +27,9 @@ namespace WireMock.Server
         /// </summary>
         IEnumerable<MappingModel> MappingModels { get; }
 
-        /// <summary>
+        // <summary>
-        /// Gets the mappings.
+        // Gets the mappings.
-        /// </summary>
+        // </summary>
         //[PublicAPI]
         //IEnumerable<IMapping> Mappings { get; }
 

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

@@ -4,7 +4,7 @@
     <Description>Commonly used interfaces, models, enumerations and types.</Description>
     <AssemblyTitle>WireMock.Net.Abstractions</AssemblyTitle>
     <Authors>Stef Heyenrath</Authors>
-    <TargetFrameworks>netstandard1.0;netstandard2.0;netstandard2.1;net45</TargetFrameworks>
+    <TargetFrameworks>net45;netstandard1.0;netstandard2.0;netstandard2.1</TargetFrameworks>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <AssemblyName>WireMock.Net.Abstractions</AssemblyName>
     <PackageId>WireMock.Net.Abstractions</PackageId>

src/WireMock.Net.FluentAssertions/Assertions/WireMockAssertions.cs

@@ -8,19 +8,20 @@ namespace WireMock.FluentAssertions
 {
     public class WireMockAssertions
     {
-        private readonly IWireMockServer _instance;
+        private readonly IWireMockServer _subject;
 
-        public WireMockAssertions(IWireMockServer instance, int? callsCount)
+        public WireMockAssertions(IWireMockServer subject, int? callsCount)
         {
-            _instance = instance;
+            _subject = subject;
         }
 
         [CustomAssertion]
-        public AndConstraint<WireMockAssertions> AtAbsoluteUrl(string absoluteUrl, string because = "", params object[] becauseArgs)
+        public AndConstraint<WireMockAssertions> AtAbsoluteUrl(string absoluteUrl, string because = "",
+            params object[] becauseArgs)
         {
             Execute.Assertion
                 .BecauseOf(because, becauseArgs)
-                .Given(() => _instance.LogEntries.Select(x => x.RequestMessage).ToList())
+                .Given(() => _subject.LogEntries.Select(x => x.RequestMessage).ToList())
                 .ForCondition(requests => requests.Any())
                 .FailWith(
                     "Expected {context:wiremockserver} to have been called at address matching the absolute url {0}{reason}, but no calls were made.",
@@ -33,5 +34,43 @@ namespace WireMock.FluentAssertions
 
             return new AndConstraint<WireMockAssertions>(this);
         }
+
+        [CustomAssertion]
+        public AndConstraint<WireMockAssertions> WithHeader(string expectedKey, string value,
+            string because = "", params object[] becauseArgs)
+            => WithHeader(expectedKey, new[] {value}, because, becauseArgs);
+
+        [CustomAssertion]
+        public AndConstraint<WireMockAssertions> WithHeader(string expectedKey, string[] expectedValues,
+            string because = "", params object[] becauseArgs)
+        {
+            var headersDictionary = _subject.LogEntries.SelectMany(x => x.RequestMessage.Headers)
+                .ToDictionary(x => x.Key, x => x.Value);
+
+            using (new AssertionScope("headers from requests sent"))
+            {
+                headersDictionary.Should().ContainKey(expectedKey, because, becauseArgs);
+            }
+
+            using (new AssertionScope($"header \"{expectedKey}\" from requests sent with value(s)"))
+            {
+                if (expectedValues.Length == 1)
+                {
+                    headersDictionary[expectedKey].Should().Contain(expectedValues.First());
+                }
+                else
+                {
+                    var trimmedHeaderValues = string.Join(",", headersDictionary[expectedKey].Select(x => x)).Split(',')
+                        .Select(x => x.Trim())
+                        .ToList();
+                    foreach (var expectedValue in expectedValues)
+                    {
+                        trimmedHeaderValues.Should().Contain(expectedValue);
+                    }
+                }
+            }
+
+            return new AndConstraint<WireMockAssertions>(this);
+        }
     }
 }

src/WireMock.Net.FluentAssertions/WireMock.Net.FluentAssertions.csproj

@@ -1,11 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
 	<PropertyGroup>
-		<!--<Version>1.2.13-preview-01</Version>-->
 		<Description>FluentAssertions extensions for WireMock.Net</Description>
 		<AssemblyTitle>WireMock.Net.FluentAssertions</AssemblyTitle>
 		<Authors>Mahmoud Ali;Stef Heyenrath</Authors>
-		<TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1;net451</TargetFrameworks>
+		<TargetFrameworks>net451;netstandard1.3;netstandard2.0;netstandard2.1</TargetFrameworks>
 		<GenerateDocumentationFile>true</GenerateDocumentationFile>
 		<AssemblyName>WireMock.Net.FluentAssertions</AssemblyName>
 		<PackageId>WireMock.Net.FluentAssertions</PackageId>

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

@@ -1,37 +1,36 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <PropertyGroup>
+	<PropertyGroup>
-    <Description>An OpenApi (swagger) parser to generate MappingModel or mapping.json file.</Description>
+		<Description>An OpenApi (swagger) parser to generate MappingModel or mapping.json file.</Description>
-    <!--<VersionPrefix>1.2.4-preview-01</VersionPrefix>-->
+		<TargetFrameworks>net46;netstandard2.0;netstandard2.1</TargetFrameworks>
-    <TargetFrameworks>net46;netstandard2.0</TargetFrameworks>
+		<GenerateDocumentationFile>true</GenerateDocumentationFile>
-    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+		<PackageTags>wiremock;openapi;OAS;converter;parser;openapiparser</PackageTags>
-    <PackageTags>wiremock;openapi;OAS;converter;parser;openapiparser</PackageTags>
+		<ProjectGuid>{D3804228-91F4-4502-9595-39584E5AADAD}</ProjectGuid>
-    <ProjectGuid>{D3804228-91F4-4502-9595-39584E5AADAD}</ProjectGuid>
+		<PublishRepositoryUrl>true</PublishRepositoryUrl>
-    <PublishRepositoryUrl>true</PublishRepositoryUrl>
+		<CodeAnalysisRuleSet>../WireMock.Net/WireMock.Net.ruleset</CodeAnalysisRuleSet>
-    <CodeAnalysisRuleSet>../WireMock.Net/WireMock.Net.ruleset</CodeAnalysisRuleSet>
+		<SignAssembly>true</SignAssembly>
-    <SignAssembly>true</SignAssembly>
+		<AssemblyOriginatorKeyFile>../WireMock.Net/WireMock.Net.snk</AssemblyOriginatorKeyFile>
-    <AssemblyOriginatorKeyFile>../WireMock.Net/WireMock.Net.snk</AssemblyOriginatorKeyFile>
+		<PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
-    <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
+	</PropertyGroup>
-  </PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)' == 'Release'">
+	<PropertyGroup Condition="'$(Configuration)' == 'Release'">
-    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+		<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-  </PropertyGroup>
+	</PropertyGroup>
 
-  <ItemGroup>
+	<ItemGroup>
-    <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
+		<PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
-    <PackageReference Include="Microsoft.OpenApi.Readers" Version="1.2.0" />
+		<PackageReference Include="Microsoft.OpenApi.Readers" Version="1.2.3" />
-    <PackageReference Include="RamlToOpenApiConverter" Version="0.1.1" />
+		<PackageReference Include="RamlToOpenApiConverter" Version="0.1.1" />
-    <PackageReference Include="JetBrains.Annotations" Version="2020.1.0" PrivateAssets="All" />
+		<PackageReference Include="JetBrains.Annotations" Version="2020.1.0" PrivateAssets="All" />
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
+		<PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
-  </ItemGroup>
+	</ItemGroup>
 
-  <ItemGroup>
+	<ItemGroup>
-    <ProjectReference Include="..\WireMock.Net.Abstractions\WireMock.Net.Abstractions.csproj" />
+		<ProjectReference Include="..\WireMock.Net.Abstractions\WireMock.Net.Abstractions.csproj" />
-  </ItemGroup>
+	</ItemGroup>
 
-  <ItemGroup>
+	<ItemGroup>
-    <Folder Include="Options\" />
+		<Folder Include="Options\" />
-  </ItemGroup>
+	</ItemGroup>
 
 </Project>

src/WireMock.Net.RestClient/WireMock.Net.RestClient.csproj

@@ -4,7 +4,7 @@
     <Description>A RestClient using RestEase to access the admin interface.</Description>
     <AssemblyTitle>WireMock.Net.RestClient</AssemblyTitle>
     <Authors>Stef Heyenrath</Authors>
-    <TargetFrameworks>netstandard1.1;netstandard2.0;netstandard2.1;net45</TargetFrameworks>
+    <TargetFrameworks>net45;netstandard1.1;netstandard2.0;netstandard2.1</TargetFrameworks>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <AssemblyName>WireMock.Net.RestClient</AssemblyName>
     <PackageId>WireMock.Net.RestClient</PackageId>

src/WireMock.Net.StandAlone/StandAloneApp.cs

@@ -13,9 +13,9 @@ namespace WireMock.Net.StandAlone
     public static class StandAloneApp
     {
         /// <summary>
-        /// Start WireMock.Net standalone Server based on the FluentMockServerSettings.
+        /// Start WireMock.Net standalone Server based on the IWireMockServerSettings.
         /// </summary>
-        /// <param name="settings">The FluentMockServerSettings</param>
+        /// <param name="settings">The IWireMockServerSettings</param>
         [PublicAPI]
         public static WireMockServer Start([NotNull] IWireMockServerSettings settings)
         {

src/WireMock.Net.StandAlone/WireMock.Net.StandAlone.csproj

@@ -3,7 +3,7 @@
     <Description>Lightweight StandAlone Http Mocking Server for .Net.</Description>
     <AssemblyTitle>WireMock.Net.StandAlone</AssemblyTitle>
     <Authors>Stef Heyenrath</Authors>
-    <TargetFrameworks>net451;net452;net46;net461;netstandard1.3;netstandard2.0;netstandard2.1</TargetFrameworks>
+    <TargetFrameworks>net451;net452;net46;net461;netstandard1.3;netstandard2.0;netstandard2.1;netcoreapp3.1</TargetFrameworks>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <AssemblyName>WireMock.Net.StandAlone</AssemblyName>
     <PackageId>WireMock.Net.StandAlone</PackageId>

src/WireMock.Net/Http/HttpClientHelper.cs

@@ -13,7 +13,7 @@ namespace WireMock.Http
     {
         public static HttpClient CreateHttpClient(IProxyAndRecordSettings settings)
         {
-#if NETSTANDARD
+#if NETSTANDARD || NETCOREAPP3_1
             var handler = new HttpClientHandler
             {
                 CheckCertificateRevocationList = false,

src/WireMock.Net/IMapping.cs

@@ -51,6 +51,12 @@ namespace WireMock
         [CanBeNull]
         string NextState { get; }
 
+        /// <summary>
+        /// The number of times this match should be matched before the state will be changed to the next state.
+        /// </summary>
+        [CanBeNull]
+        int? StateTimes { get; }
+
         /// <summary>
         /// The Request matcher.
         /// </summary>

src/WireMock.Net/Mapping.cs

@@ -33,6 +33,9 @@ namespace WireMock
         /// <inheritdoc cref="IMapping.NextState" />
         public string NextState { get; }
 
+        /// <inheritdoc cref="IMapping.StateTimes" />
+        public int? StateTimes { get; }
+
         /// <inheritdoc cref="IMapping.RequestMatcher" />
         public IRequestMatcher RequestMatcher { get; }
 
@@ -64,9 +67,10 @@ namespace WireMock
         /// <param name="scenario">The scenario. [Optional]</param>
         /// <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>
         public Mapping(Guid guid, [CanBeNull] string title, [CanBeNull] string path,
             [NotNull] IWireMockServerSettings settings, [NotNull] IRequestMatcher requestMatcher, [NotNull] IResponseProvider provider,
-            int priority, [CanBeNull] string scenario, [CanBeNull] string executionConditionState, [CanBeNull] string nextState)
+            int priority, [CanBeNull] string scenario, [CanBeNull] string executionConditionState, [CanBeNull] string nextState, [CanBeNull] int? stateTimes)
         {
             Guid = guid;
             Title = title;
@@ -78,6 +82,7 @@ namespace WireMock
             Scenario = scenario;
             ExecutionConditionState = executionConditionState;
             NextState = nextState;
+            StateTimes = stateTimes; 
         }
 
         /// <inheritdoc cref="IMapping.ProvideResponseAsync" />

src/WireMock.Net/Matchers/CSharpCodeMatcher.cs

@@ -29,6 +29,9 @@ namespace WireMock.Matchers
 
         public MatchBehaviour MatchBehaviour { get; }
 
+        /// <inheritdoc cref="IMatcher.ThrowException"/>
+        public bool ThrowException { get; }
+
         private readonly string[] _patterns;
 
         /// <summary>
@@ -49,6 +52,7 @@ namespace WireMock.Matchers
             Check.NotNull(patterns, nameof(patterns));
 
             MatchBehaviour = matchBehaviour;
+            ThrowException = false;
             _patterns = patterns;
         }
 
@@ -147,7 +151,7 @@ namespace WireMock.Matchers
                 throw new WireMockException("CSharpCodeMatcher: Problem calling method 'IsMatch' in WireMock.CodeHelper", ex);
             }
 
-#elif (NETSTANDARD2_0 || NETSTANDARD2_1)
+#elif (NETSTANDARD2_0 || NETSTANDARD2_1 || NETCOREAPP3_1)
             dynamic script;
             try
             {
@@ -156,7 +160,7 @@ namespace WireMock.Matchers
 #if NETSTANDARD2_0
                 script = csscript.GenericExtensions.CreateObject(assembly, "*");
 #else
-                script = CSScriptLib.ReflectionExtensions.CreateObject(assembly,"*");
+                script = CSScriptLib.ReflectionExtensions.CreateObject(assembly, "*");
 #endif
             }
             catch (Exception ex)

src/WireMock.Net/Matchers/ContentTypeMatcher.cs

@@ -1,73 +1,75 @@
-using System.Net.Http.Headers;
+using System.Net.Http.Headers;
-using JetBrains.Annotations;
+using JetBrains.Annotations;
-
+
-namespace WireMock.Matchers
+namespace WireMock.Matchers
-{
+{
-    /// <summary>
+    /// <summary>
-    /// ContentTypeMatcher which accepts also all charsets
+    /// ContentTypeMatcher which accepts also all charsets
-    /// </summary>
+    /// </summary>
-    /// <seealso cref="RegexMatcher" />
+    /// <seealso cref="RegexMatcher" />
-    public class ContentTypeMatcher : WildcardMatcher
+    public class ContentTypeMatcher : WildcardMatcher
-    {
+    {
-        private readonly string[] _patterns;
+        private readonly string[] _patterns;
-
+
-        /// <summary>
+        /// <summary>
-        /// Initializes a new instance of the <see cref="ContentTypeMatcher"/> class.
+        /// Initializes a new instance of the <see cref="ContentTypeMatcher"/> class.
-        /// </summary>
+        /// </summary>
-        /// <param name="pattern">The pattern.</param>
+        /// <param name="pattern">The pattern.</param>
-        /// <param name="ignoreCase">IgnoreCase (default false)</param>
+        /// <param name="ignoreCase">IgnoreCase (default false)</param>
-        public ContentTypeMatcher([NotNull] string pattern, bool ignoreCase = false) : this(new[] { pattern }, ignoreCase)
+        public ContentTypeMatcher([NotNull] string pattern, bool ignoreCase = false) : this(new[] { pattern }, ignoreCase)
-        {
+        {
-        }
+        }
-
+
-        /// <summary>
+        /// <summary>
-        /// Initializes a new instance of the <see cref="ContentTypeMatcher"/> class.
+        /// Initializes a new instance of the <see cref="ContentTypeMatcher"/> class.
-        /// </summary>
+        /// </summary>
-        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="matchBehaviour">The match behaviour.</param>
-        /// <param name="pattern">The pattern.</param>
+        /// <param name="pattern">The pattern.</param>
-        /// <param name="ignoreCase">IgnoreCase (default false)</param>
+        /// <param name="ignoreCase">IgnoreCase (default false)</param>
-        public ContentTypeMatcher(MatchBehaviour matchBehaviour, [NotNull] string pattern, bool ignoreCase = false) : this(matchBehaviour, new[] { pattern }, ignoreCase)
+        public ContentTypeMatcher(MatchBehaviour matchBehaviour, [NotNull] string pattern, bool ignoreCase = false) : this(matchBehaviour, new[] { pattern }, ignoreCase)
-        {
+        {
-        }
+        }
-
+
-        /// <summary>
+        /// <summary>
-        /// Initializes a new instance of the <see cref="ContentTypeMatcher"/> class.
+        /// Initializes a new instance of the <see cref="ContentTypeMatcher"/> class.
-        /// </summary>
+        /// </summary>
-        /// <param name="patterns">The patterns.</param>
+        /// <param name="patterns">The patterns.</param>
-        /// <param name="ignoreCase">IgnoreCase (default false)</param>
+        /// <param name="ignoreCase">IgnoreCase (default false)</param>
-        public ContentTypeMatcher([NotNull] string[] patterns, bool ignoreCase = false) : this(MatchBehaviour.AcceptOnMatch, patterns, ignoreCase)
+        public ContentTypeMatcher([NotNull] string[] patterns, bool ignoreCase = false) : this(MatchBehaviour.AcceptOnMatch, patterns, ignoreCase)
-        {
+        {
-        }
+        }
-
+
-        /// <summary>
+        /// <summary>
-        /// Initializes a new instance of the <see cref="ContentTypeMatcher"/> class.
+        /// Initializes a new instance of the <see cref="ContentTypeMatcher"/> class.
-        /// </summary>
+        /// </summary>
-        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="matchBehaviour">The match behaviour.</param>
-        /// <param name="patterns">The patterns.</param>
+        /// <param name="patterns">The patterns.</param>
-        /// <param name="ignoreCase">IgnoreCase (default false)</param>
+        /// <param name="ignoreCase">IgnoreCase (default false)</param>
-        public ContentTypeMatcher(MatchBehaviour matchBehaviour, [NotNull] string[] patterns, bool ignoreCase = false) : base(matchBehaviour, patterns, ignoreCase)
+        /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-        {
+        public ContentTypeMatcher(MatchBehaviour matchBehaviour, [NotNull] string[] patterns, bool ignoreCase = false, bool throwException = false) :
-            _patterns = patterns;
+            base(matchBehaviour, patterns, ignoreCase, throwException)
-        }
+        {
-
+            _patterns = patterns;
-        /// <inheritdoc cref="RegexMatcher.IsMatch"/>
+        }
-        public override double IsMatch(string input)
+
-        {
+        /// <inheritdoc cref="RegexMatcher.IsMatch"/>
-            if (string.IsNullOrEmpty(input) || !MediaTypeHeaderValue.TryParse(input, out MediaTypeHeaderValue contentType))
+        public override double IsMatch(string input)
-            {
+        {
-                return MatchBehaviourHelper.Convert(MatchBehaviour, MatchScores.Mismatch);
+            if (string.IsNullOrEmpty(input) || !MediaTypeHeaderValue.TryParse(input, out MediaTypeHeaderValue contentType))
-            }
+            {
-
+                return MatchBehaviourHelper.Convert(MatchBehaviour, MatchScores.Mismatch);
-            return base.IsMatch(contentType.MediaType);
+            }
-        }
+
-
+            return base.IsMatch(contentType.MediaType);
-        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
+        }
-        public override string[] GetPatterns()
+
-        {
+        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
-            return _patterns;
+        public override string[] GetPatterns()
-        }
+        {
-
+            return _patterns;
-        /// <inheritdoc cref="IMatcher.Name"/>
+        }
-        public override string Name => "ContentTypeMatcher";
+
-    }
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public override string Name => "ContentTypeMatcher";
+    }
 }

src/WireMock.Net/Matchers/ExactMatcher.cs

@@ -1,59 +1,64 @@
-using System.Linq;
+using System.Linq;
-using JetBrains.Annotations;
+using JetBrains.Annotations;
-using WireMock.Validation;
+using WireMock.Validation;
-
+
-namespace WireMock.Matchers
+namespace WireMock.Matchers
-{
+{
-    /// <summary>
+    /// <summary>
-    /// ExactMatcher
+    /// ExactMatcher
-    /// </summary>
+    /// </summary>
-    /// <seealso cref="IStringMatcher" />
+    /// <seealso cref="IStringMatcher" />
-    public class ExactMatcher : IStringMatcher
+    public class ExactMatcher : IStringMatcher
-    {
+    {
-        private readonly string[] _values;
+        private readonly string[] _values;
-
+
-        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
-        public MatchBehaviour MatchBehaviour { get; }
+        public MatchBehaviour MatchBehaviour { get; }
-
+
-        /// <summary>
+        /// <inheritdoc cref="IMatcher.ThrowException"/>
-        /// Initializes a new instance of the <see cref="ExactMatcher"/> class.
+        public bool ThrowException { get; }
-        /// </summary>
+
-        /// <param name="values">The values.</param>
+        /// <summary>
-        public ExactMatcher([NotNull] params string[] values) : this(MatchBehaviour.AcceptOnMatch, values)
+        /// Initializes a new instance of the <see cref="ExactMatcher"/> class.
-        {
+        /// </summary>
-        }
+        /// <param name="values">The values.</param>
-
+        public ExactMatcher([NotNull] params string[] values) : this(MatchBehaviour.AcceptOnMatch, false, values)
-        /// <summary>
+        {
-        /// Initializes a new instance of the <see cref="ExactMatcher"/> class.
+        }
-        /// </summary>
+
-        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <summary>
-        /// <param name="values">The values.</param>
+        /// Initializes a new instance of the <see cref="ExactMatcher"/> class.
-        public ExactMatcher(MatchBehaviour matchBehaviour, [NotNull] params string[] values)
+        /// </summary>
-        {
+        /// <param name="matchBehaviour">The match behaviour.</param>
-            Check.HasNoNulls(values, nameof(values));
+        /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-
+        /// <param name="values">The values.</param>
-            _values = values;
+        public ExactMatcher(MatchBehaviour matchBehaviour, bool throwException = false, [NotNull] params string[] values)
-            MatchBehaviour = matchBehaviour;
+        {
-        }
+            Check.HasNoNulls(values, nameof(values));
-
+
-        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
+            MatchBehaviour = matchBehaviour;
-        public double IsMatch(string input)
+            ThrowException = throwException;
-        {
+            _values = values;
-            if (_values.Length == 1)
+        }
-            {
+
-                return MatchBehaviourHelper.Convert(MatchBehaviour, MatchScores.ToScore(_values[0] == input));
+        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
-            }
+        public double IsMatch(string input)
-
+        {
-            return MatchBehaviourHelper.Convert(MatchBehaviour, MatchScores.ToScore(_values.Contains(input)));
+            if (_values.Length == 1)
-        }
+            {
-
+                return MatchBehaviourHelper.Convert(MatchBehaviour, MatchScores.ToScore(_values[0] == input));
-        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
+            }
-        public string[] GetPatterns()
+
-        {
+            return MatchBehaviourHelper.Convert(MatchBehaviour, MatchScores.ToScore(_values.Contains(input)));
-            return _values;
+        }
-        }
+
-
+        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
-        /// <inheritdoc cref="IMatcher.Name"/>
+        public string[] GetPatterns()
-        public string Name => "ExactMatcher";
+        {
-    }
+            return _values;
+        }
+
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public string Name => "ExactMatcher";
+    }
 }

src/WireMock.Net/Matchers/ExactObjectMatcher.cs

@@ -1,78 +1,83 @@
-using JetBrains.Annotations;
+using JetBrains.Annotations;
-using System.Linq;
+using System.Linq;
-using WireMock.Validation;
+using WireMock.Validation;
-
+
-namespace WireMock.Matchers
+namespace WireMock.Matchers
-{
+{
-    /// <summary>
+    /// <summary>
-    /// ExactObjectMatcher
+    /// ExactObjectMatcher
-    /// </summary>
+    /// </summary>
-    /// <seealso cref="IObjectMatcher" />
+    /// <seealso cref="IObjectMatcher" />
-    public class ExactObjectMatcher : IObjectMatcher
+    public class ExactObjectMatcher : IObjectMatcher
-    {
+    {
-        /// <summary>
+        /// <summary>
-        /// Gets the value as object.
+        /// Gets the value as object.
-        /// </summary>
+        /// </summary>
-        public object ValueAsObject { get; }
+        public object ValueAsObject { get; }
-
+
-        /// <summary>
+        /// <summary>
-        /// Gets the value as byte[].
+        /// Gets the value as byte[].
-        /// </summary>
+        /// </summary>
-        public byte[] ValueAsBytes { get; }
+        public byte[] ValueAsBytes { get; }
-
+
-        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
-        public MatchBehaviour MatchBehaviour { get; }
+        public MatchBehaviour MatchBehaviour { get; }
-
+        
-        /// <summary>
+        /// <inheritdoc cref="IMatcher.ThrowException"/>
-        /// Initializes a new instance of the <see cref="ExactObjectMatcher"/> class.
+        public bool ThrowException { get; }
-        /// </summary>
+        
-        /// <param name="value">The value.</param>
+        /// <summary>
-        public ExactObjectMatcher([NotNull] object value) : this(MatchBehaviour.AcceptOnMatch, value)
+        /// Initializes a new instance of the <see cref="ExactObjectMatcher"/> class.
-        {
+        /// </summary>
-        }
+        /// <param name="value">The value.</param>
-
+        public ExactObjectMatcher([NotNull] object value) : this(MatchBehaviour.AcceptOnMatch, value)
-        /// <summary>
+        {
-        /// Initializes a new instance of the <see cref="ExactObjectMatcher"/> class.
+        }
-        /// </summary>
+
-        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <summary>
-        /// <param name="value">The value.</param>
+        /// Initializes a new instance of the <see cref="ExactObjectMatcher"/> class.
-        public ExactObjectMatcher(MatchBehaviour matchBehaviour, [NotNull] object value)
+        /// </summary>
-        {
+        /// <param name="matchBehaviour">The match behaviour.</param>
-            Check.NotNull(value, nameof(value));
+        /// <param name="value">The value.</param>
-
+        public ExactObjectMatcher(MatchBehaviour matchBehaviour, [NotNull] object value)
-            ValueAsObject = value;
+        {
-            MatchBehaviour = matchBehaviour;
+            Check.NotNull(value, nameof(value));
-        }
+
-
+            ValueAsObject = value;
-        /// <summary>
+            MatchBehaviour = matchBehaviour;
-        /// Initializes a new instance of the <see cref="ExactObjectMatcher"/> class.
+        }
-        /// </summary>
+
-        /// <param name="value">The value.</param>
+        /// <summary>
-        public ExactObjectMatcher([NotNull] byte[] value) : this(MatchBehaviour.AcceptOnMatch, value)
+        /// Initializes a new instance of the <see cref="ExactObjectMatcher"/> class.
-        {
+        /// </summary>
-        }
+        /// <param name="value">The value.</param>
-
+        public ExactObjectMatcher([NotNull] byte[] value) : this(MatchBehaviour.AcceptOnMatch, value)
-        /// <summary>
+        {
-        /// Initializes a new instance of the <see cref="ExactObjectMatcher"/> class.
+        }
-        /// </summary>
+
-        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <summary>
-        /// <param name="value">The value.</param>
+        /// Initializes a new instance of the <see cref="ExactObjectMatcher"/> class.
-        public ExactObjectMatcher(MatchBehaviour matchBehaviour, [NotNull] byte[] value)
+        /// </summary>
-        {
+        /// <param name="matchBehaviour">The match behaviour.</param>
-            Check.NotNull(value, nameof(value));
+        /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-
+        /// <param name="value">The value.</param>
-            ValueAsBytes = value;
+        public ExactObjectMatcher(MatchBehaviour matchBehaviour, [NotNull] byte[] value, bool throwException = false)
-            MatchBehaviour = matchBehaviour;
+        {
-        }
+            Check.NotNull(value, nameof(value));
-
+
-        /// <inheritdoc cref="IObjectMatcher.IsMatch"/>
+            MatchBehaviour = matchBehaviour;
-        public double IsMatch(object input)
+            ThrowException = throwException;
-        {
+            ValueAsBytes = value;
-            bool equals = ValueAsObject != null ? Equals(ValueAsObject, input) : ValueAsBytes.SequenceEqual((byte[])input);
+        }
-            return MatchBehaviourHelper.Convert(MatchBehaviour, MatchScores.ToScore(equals));
+
-        }
+        /// <inheritdoc cref="IObjectMatcher.IsMatch"/>
-
+        public double IsMatch(object input)
-        /// <inheritdoc cref="IMatcher.Name"/>
+        {
-        public string Name => "ExactObjectMatcher";
+            bool equals = ValueAsObject != null ? Equals(ValueAsObject, input) : ValueAsBytes.SequenceEqual((byte[])input);
-    }
+            return MatchBehaviourHelper.Convert(MatchBehaviour, MatchScores.ToScore(equals));
+        }
+
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public string Name => "ExactObjectMatcher";
+    }
 }

src/WireMock.Net/Matchers/IMatcher.cs

@@ -1,18 +1,23 @@
-namespace WireMock.Matchers
+namespace WireMock.Matchers
-{
+{
-    /// <summary>
+    /// <summary>
-    /// IMatcher
+    /// IMatcher
-    /// </summary>
+    /// </summary>
-    public interface IMatcher
+    public interface IMatcher
-    {
+    {
-        /// <summary>
+        /// <summary>
-        /// Gets the name.
+        /// Gets the name.
-        /// </summary>
+        /// </summary>
-        string Name { get; }
+        string Name { get; }
-
+
-        /// <summary>
+        /// <summary>
-        /// Gets the match behaviour.
+        /// Gets the match behaviour.
-        /// </summary>
+        /// </summary>
-        MatchBehaviour MatchBehaviour { get; }
+        MatchBehaviour MatchBehaviour { get; }
-    }
+
+        /// <summary>
+        /// Should this matcher throw an exception?
+        /// </summary>
+        bool ThrowException { get; }
+    }
 }

src/WireMock.Net/Matchers/JSONPathMatcher.cs

@@ -1,99 +1,110 @@
-using System.Linq;
+using System.Linq;
-using JetBrains.Annotations;
+using JetBrains.Annotations;
-using Newtonsoft.Json;
+using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Linq;
-using WireMock.Validation;
+using WireMock.Validation;
-
+
-namespace WireMock.Matchers
+namespace WireMock.Matchers
-{
+{
-    /// <summary>
+    /// <summary>
-    /// JsonPathMatcher
+    /// JsonPathMatcher
-    /// </summary>
+    /// </summary>
-    /// <seealso cref="IMatcher" />
+    /// <seealso cref="IMatcher" />
-    /// <seealso cref="IObjectMatcher" />
+    /// <seealso cref="IObjectMatcher" />
-    public class JsonPathMatcher : IStringMatcher, IObjectMatcher
+    public class JsonPathMatcher : IStringMatcher, IObjectMatcher
-    {
+    {
-        private readonly string[] _patterns;
+        private readonly string[] _patterns;
-
+
-        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
-        public MatchBehaviour MatchBehaviour { get; }
+        public MatchBehaviour MatchBehaviour { get; }
-
+
-        /// <summary>
+        /// <inheritdoc cref="IMatcher.ThrowException"/>
-        /// Initializes a new instance of the <see cref="JsonPathMatcher"/> class.
+        public bool ThrowException { get; }
-        /// </summary>
+
-        /// <param name="patterns">The patterns.</param>
+        /// <summary>
-        public JsonPathMatcher([NotNull] params string[] patterns) : this(MatchBehaviour.AcceptOnMatch, patterns)
+        /// Initializes a new instance of the <see cref="JsonPathMatcher"/> class.
-        {
+        /// </summary>
-        }
+        /// <param name="patterns">The patterns.</param>
-
+        public JsonPathMatcher([NotNull] params string[] patterns) : this(MatchBehaviour.AcceptOnMatch, false, patterns)
-        /// <summary>
+        {
-        /// Initializes a new instance of the <see cref="JsonPathMatcher"/> class.
+        }
-        /// </summary>
+
-        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <summary>
-        /// <param name="patterns">The patterns.</param>
+        /// Initializes a new instance of the <see cref="JsonPathMatcher"/> class.
-        public JsonPathMatcher(MatchBehaviour matchBehaviour, [NotNull] params string[] patterns)
+        /// </summary>
-        {
+        /// <param name="matchBehaviour">The match behaviour.</param>
-            Check.NotNull(patterns, nameof(patterns));
+        /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-
+        /// <param name="patterns">The patterns.</param>
-            MatchBehaviour = matchBehaviour;
+        public JsonPathMatcher(MatchBehaviour matchBehaviour, bool throwException = false, [NotNull] params string[] patterns)
-            _patterns = patterns;
+        {
-        }
+            Check.NotNull(patterns, nameof(patterns));
-
+
-        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
+            MatchBehaviour = matchBehaviour;
-        public double IsMatch(string input)
+            ThrowException = throwException;
-        {
+            _patterns = patterns;
-            double match = MatchScores.Mismatch;
+        }
-            if (input != null)
+
-            {
+        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
-                try
+        public double IsMatch(string input)
-                {
+        {
-                    var jtoken = JToken.Parse(input);
+            double match = MatchScores.Mismatch;
-                    match = IsMatch(jtoken);
+            if (input != null)
-                }
+            {
-                catch (JsonException)
+                try
-                {
+                {
-                    // just ignore JsonException
+                    var jtoken = JToken.Parse(input);
-                }
+                    match = IsMatch(jtoken);
-            }
+                }
-
+                catch (JsonException)
-            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
+                {
-        }
+                    if (ThrowException)
-
+                    {
-        /// <inheritdoc cref="IObjectMatcher.IsMatch"/>
+                        throw;
-        public double IsMatch(object input)
+                    }
-        {
+                }
-            double match = MatchScores.Mismatch;
+            }
-
+
-            // When input is null or byte[], return Mismatch.
+            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
-            if (input != null && !(input is byte[]))
+        }
-            {
+
-                try
+        /// <inheritdoc cref="IObjectMatcher.IsMatch"/>
-                {
+        public double IsMatch(object input)
-                    // Check if JToken or object
+        {
-                    JToken jtoken = input is JToken token ? token : JObject.FromObject(input);
+            double match = MatchScores.Mismatch;
-                    match = IsMatch(jtoken);
+
-                }
+            // When input is null or byte[], return Mismatch.
-                catch (JsonException)
+            if (input != null && !(input is byte[]))
-                {
+            {
-                    // just ignore JsonException
+                try
-                }
+                {
-            }
+                    // Check if JToken or object
-
+                    JToken jtoken = input is JToken token ? token : JObject.FromObject(input);
-            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
+                    match = IsMatch(jtoken);
-        }
+                }
-
+                catch (JsonException)
-        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
+                {
-        public string[] GetPatterns()
+                    if (ThrowException)
-        {
+                    {
-            return _patterns;
+                        throw;
-        }
+                    }
-
+                }
-        /// <inheritdoc cref="IMatcher.Name"/>
+            }
-        public string Name => "JsonPathMatcher";
+
-
+            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
-        private double IsMatch(JToken jtoken)
+        }
-        {
+
-            return MatchScores.ToScore(_patterns.Select(pattern => jtoken.SelectToken(pattern) != null));
+        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
-        }
+        public string[] GetPatterns()
-    }
+        {
+            return _patterns;
+        }
+
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public string Name => "JsonPathMatcher";
+
+        private double IsMatch(JToken jtoken)
+        {
+            return MatchScores.ToScore(_patterns.Select(pattern => jtoken.SelectToken(pattern) != null));
+        }
+    }
 }

src/WireMock.Net/Matchers/JmesPathMatcher.cs

@@ -1,83 +1,100 @@
-using DevLab.JmesPath;
+using DevLab.JmesPath;
-using JetBrains.Annotations;
+using JetBrains.Annotations;
-using Newtonsoft.Json;
+using Newtonsoft.Json;
-using System.Linq;
+using System.Linq;
-using WireMock.Validation;
+using WireMock.Validation;
-
+
-namespace WireMock.Matchers
+namespace WireMock.Matchers
-{
+{
-    /// <summary>
+    /// <summary>
-    /// http://jmespath.org/
+    /// http://jmespath.org/
-    /// </summary>
+    /// </summary>
-    public class JmesPathMatcher : IStringMatcher, IObjectMatcher
+    public class JmesPathMatcher : IStringMatcher, IObjectMatcher
-    {
+    {
-        private readonly string[] _patterns;
+        private readonly string[] _patterns;
-
+
-        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
-        public MatchBehaviour MatchBehaviour { get; }
+        public MatchBehaviour MatchBehaviour { get; }
-
+
-        /// <summary>
+        /// <inheritdoc cref="IMatcher.ThrowException"/>
-        /// Initializes a new instance of the <see cref="JmesPathMatcher"/> class.
+        public bool ThrowException { get; }
-        /// </summary>
+
-        /// <param name="patterns">The patterns.</param>
+        /// <summary>
-        public JmesPathMatcher([NotNull] params string[] patterns) : this(MatchBehaviour.AcceptOnMatch, patterns)
+        /// Initializes a new instance of the <see cref="JmesPathMatcher"/> class.
-        {
+        /// </summary>
-        }
+        /// <param name="patterns">The patterns.</param>
-
+        public JmesPathMatcher([NotNull] params string[] patterns) : this(MatchBehaviour.AcceptOnMatch, false, patterns)
-        /// <summary>
+        {
-        /// Initializes a new instance of the <see cref="JmesPathMatcher"/> class.
+        }
-        /// </summary>
+
-        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <summary>
-        /// <param name="patterns">The patterns.</param>
+        /// Initializes a new instance of the <see cref="JmesPathMatcher"/> class.
-        public JmesPathMatcher(MatchBehaviour matchBehaviour, [NotNull] params string[] patterns)
+        /// </summary>
-        {
+        /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-            Check.NotNull(patterns, nameof(patterns));
+        /// <param name="patterns">The patterns.</param>
-
+        public JmesPathMatcher(bool throwException = false, [NotNull] params string[] patterns) : this(MatchBehaviour.AcceptOnMatch, throwException, patterns)
-            MatchBehaviour = matchBehaviour;
+        {
-            _patterns = patterns;
+        }
-        }
+
-
+        /// <summary>
-        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
+        /// Initializes a new instance of the <see cref="JmesPathMatcher"/> class.
-        public double IsMatch(string input)
+        /// </summary>
-        {
+        /// <param name="matchBehaviour">The match behaviour.</param>
-            double match = MatchScores.Mismatch;
+        /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-            if (input != null)
+        /// <param name="patterns">The patterns.</param>
-            {
+        public JmesPathMatcher(MatchBehaviour matchBehaviour, bool throwException = false, [NotNull] params string[] patterns)
-                try
+        {
-                {
+            Check.NotNull(patterns, nameof(patterns));
-                    match = MatchScores.ToScore(_patterns.Select(pattern => bool.Parse(new JmesPath().Transform(input, pattern))));
+
-                }
+            MatchBehaviour = matchBehaviour;
-                catch (JsonException)
+            ThrowException = throwException;
-                {
+            _patterns = patterns;
-                    // just ignore JsonException
+        }
-                }
+
-            }
+        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
-
+        public double IsMatch(string input)
-            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
+        {
-        }
+            double match = MatchScores.Mismatch;
-
+            if (input != null)
-        /// <inheritdoc cref="IObjectMatcher.IsMatch"/>
+            {
-        public double IsMatch(object input)
+                try
-        {
+                {
-            double match = MatchScores.Mismatch;
+                    match = MatchScores.ToScore(_patterns.Select(pattern => bool.Parse(new JmesPath().Transform(input, pattern))));
-
+                }
-            // When input is null or byte[], return Mismatch.
+                catch (JsonException)
-            if (input != null && !(input is byte[]))
+                {
-            {
+                    if (ThrowException)
-                string inputAsString = JsonConvert.SerializeObject(input);
+                    {
-                return IsMatch(inputAsString);
+                        throw;
-            }
+                    }
-
+                }
-            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
+            }
-        }
+
-
+            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
-        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
+        }
-        public string[] GetPatterns()
+
-        {
+        /// <inheritdoc cref="IObjectMatcher.IsMatch"/>
-            return _patterns;
+        public double IsMatch(object input)
-        }
+        {
-
+            double match = MatchScores.Mismatch;
-        /// <inheritdoc cref="IMatcher.Name"/>
+
-        public string Name => "JmesPathMatcher";
+            // When input is null or byte[], return Mismatch.
-    }
+            if (input != null && !(input is byte[]))
+            {
+                string inputAsString = JsonConvert.SerializeObject(input);
+                return IsMatch(inputAsString);
+            }
+
+            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
+        }
+
+        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
+        public string[] GetPatterns()
+        {
+            return _patterns;
+        }
+
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public string Name => "JmesPathMatcher";
+    }
 }

src/WireMock.Net/Matchers/JsonMatcher.cs

@@ -1,169 +1,165 @@
-using JetBrains.Annotations;
+using System.Collections;
-using Newtonsoft.Json;
+using System.Linq;
-using Newtonsoft.Json.Linq;
+using JetBrains.Annotations;
-using System.Collections;
+using Newtonsoft.Json;
-using System.Linq;
+using Newtonsoft.Json.Linq;
-using WireMock.Util;
+using WireMock.Util;
-using WireMock.Validation;
+using WireMock.Validation;
-
+
-namespace WireMock.Matchers
+namespace WireMock.Matchers
-{
+{
-    /// <summary>
+    /// <summary>
-    /// JsonMatcher
+    /// JsonMatcher
-    /// </summary>
+    /// </summary>
-    public class JsonMatcher : IValueMatcher, IIgnoreCaseMatcher
+    public class JsonMatcher : IValueMatcher, IIgnoreCaseMatcher
-    {
+    {
-        /// <inheritdoc cref="IValueMatcher.Value"/>
+        /// <inheritdoc cref="IValueMatcher.Value"/>
-        public object Value { get; }
+        public object Value { get; }
-
+
-        /// <inheritdoc cref="IMatcher.Name"/>
+        /// <inheritdoc cref="IMatcher.Name"/>
-        public string Name => "JsonMatcher";
+        public string Name => "JsonMatcher";
-
+
-        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
-        public MatchBehaviour MatchBehaviour { get; }
+        public MatchBehaviour MatchBehaviour { get; }
-
+
-        /// <inheritdoc cref="IIgnoreCaseMatcher.IgnoreCase"/>
+        /// <inheritdoc cref="IIgnoreCaseMatcher.IgnoreCase"/>
-        public bool IgnoreCase { get; }
+        public bool IgnoreCase { get; }
-
+
-        /// <summary>
+        /// <inheritdoc cref="IMatcher.ThrowException"/>
-        /// Initializes a new instance of the <see cref="JsonMatcher"/> class.
+        public bool ThrowException { get; }
-        /// </summary>
+
-        /// <param name="value">The string value to check for equality.</param>
+        private readonly JToken _valueAsJToken;
-        /// <param name="ignoreCase">Ignore the case from the PropertyName and PropertyValue (string only).</param>
+
-        public JsonMatcher([NotNull] string value, bool ignoreCase = false) : this(MatchBehaviour.AcceptOnMatch, value, ignoreCase)
+        /// <summary>
-        {
+        /// Initializes a new instance of the <see cref="JsonMatcher"/> class.
-        }
+        /// </summary>
-
+        /// <param name="value">The string value to check for equality.</param>
-        /// <summary>
+        /// <param name="ignoreCase">Ignore the case from the PropertyName and PropertyValue (string only).</param>
-        /// Initializes a new instance of the <see cref="JsonMatcher"/> class.
+        /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-        /// </summary>
+        public JsonMatcher([NotNull] string value, bool ignoreCase = false, bool throwException = false) : this(MatchBehaviour.AcceptOnMatch, value, ignoreCase, throwException)
-        /// <param name="value">The object value to check for equality.</param>
+        {
-        /// <param name="ignoreCase">Ignore the case from the PropertyName and PropertyValue (string only).</param>
+        }
-        public JsonMatcher([NotNull] object value, bool ignoreCase = false) : this(MatchBehaviour.AcceptOnMatch, value, ignoreCase)
+
-        {
+        /// <summary>
-        }
+        /// Initializes a new instance of the <see cref="JsonMatcher"/> class.
-
+        /// </summary>
-        /// <summary>
+        /// <param name="value">The object value to check for equality.</param>
-        /// Initializes a new instance of the <see cref="JsonMatcher"/> class.
+        /// <param name="ignoreCase">Ignore the case from the PropertyName and PropertyValue (string only).</param>
-        /// </summary>
+        /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-        /// <param name="matchBehaviour">The match behaviour.</param>
+        public JsonMatcher([NotNull] object value, bool ignoreCase = false, bool throwException = false) : this(MatchBehaviour.AcceptOnMatch, value, ignoreCase, throwException)
-        /// <param name="value">The string value to check for equality.</param>
+        {
-        /// <param name="ignoreCase">Ignore the case from the PropertyName and PropertyValue (string only).</param>
+        }
-        public JsonMatcher(MatchBehaviour matchBehaviour, [NotNull] string value, bool ignoreCase = false)
+
-        {
+        /// <summary>
-            Check.NotNull(value, nameof(value));
+        /// Initializes a new instance of the <see cref="JsonMatcher"/> class.
-
+        /// </summary>
-            MatchBehaviour = matchBehaviour;
+        /// <param name="matchBehaviour">The match behaviour.</param>
-            Value = value;
+        /// <param name="value">The value to check for equality.</param>
-            IgnoreCase = ignoreCase;
+        /// <param name="ignoreCase">Ignore the case from the PropertyName and PropertyValue (string only).</param>
-        }
+        /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-
+        public JsonMatcher(MatchBehaviour matchBehaviour, [NotNull] object value, bool ignoreCase = false, bool throwException = false)
-        /// <summary>
+        {
-        /// Initializes a new instance of the <see cref="JsonMatcher"/> class.
+            Check.NotNull(value, nameof(value));
-        /// </summary>
+
-        /// <param name="matchBehaviour">The match behaviour.</param>
+            MatchBehaviour = matchBehaviour;
-        /// <param name="value">The object value to check for equality.</param>
+            IgnoreCase = ignoreCase;
-        /// <param name="ignoreCase">Ignore the case from the PropertyName and PropertyValue (string only).</param>
+            ThrowException = throwException;
-        public JsonMatcher(MatchBehaviour matchBehaviour, [NotNull] object value, bool ignoreCase = false)
+
-        {
+            Value = value;
-            Check.NotNull(value, nameof(value));
+            _valueAsJToken = ConvertValueToJToken(value);
-
+        }
-            MatchBehaviour = matchBehaviour;
+
-            Value = value;
+        /// <inheritdoc cref="IObjectMatcher.IsMatch"/>
-            IgnoreCase = ignoreCase;
+        public double IsMatch(object input)
-        }
+        {
-
+            bool match = false;
-        /// <inheritdoc cref="IObjectMatcher.IsMatch"/>
+
-        public double IsMatch(object input)
+            // When input is null or byte[], return Mismatch.
-        {
+            if (input != null && !(input is byte[]))
-            bool match = false;
+            {
-
+                try
-            // When input is null or byte[], return Mismatch.
+                {
-            if (input != null && !(input is byte[]))
+                    var inputAsJToken = ConvertValueToJToken(input);
-            {
+
-                try
+                    match = DeepEquals(_valueAsJToken, inputAsJToken);
-                {
+                }
-                    // Check if JToken or object
+                catch (JsonException)
-                    JToken jtokenInput = input is JToken tokenInput ? tokenInput : JObject.FromObject(input);
+                {
-
+                    if (ThrowException)
-                    // Check if JToken, string, IEnumerable or object
+                    {
-                    JToken jtokenValue;
+                        throw;
-                    switch (Value)
+                    }
-                    {
+                }
-                        case JToken tokenValue:
+            }
-                            jtokenValue = tokenValue;
+
-                            break;
+            return MatchBehaviourHelper.Convert(MatchBehaviour, MatchScores.ToScore(match));
-
+        }
-                        case string stringValue:
+
-                            jtokenValue = JsonUtils.Parse(stringValue);
+        private static JToken ConvertValueToJToken(object value)
-                            break;
+        {
-
+            // Check if JToken, string, IEnumerable or object
-                        case IEnumerable enumerableValue:
+            switch (value)
-                            jtokenValue = JArray.FromObject(enumerableValue);
+            {
-                            break;
+                case JToken tokenValue:
-
+                    return tokenValue;
-                        default:
+
-                            jtokenValue = JObject.FromObject(Value);
+                case string stringValue:
-                            break;
+                    return JsonUtils.Parse(stringValue);
-                    }
+
-
+                case IEnumerable enumerableValue:
-                    match = DeepEquals(jtokenValue, jtokenInput);
+                    return JArray.FromObject(enumerableValue);
-                }
+
-                catch (JsonException)
+                default:
-                {
+                    return JObject.FromObject(value);
-                    // just ignore JsonException
+            }
-                }
+        }
-            }
+
-
+        private bool DeepEquals(JToken value, JToken input)
-            return MatchBehaviourHelper.Convert(MatchBehaviour, MatchScores.ToScore(match));
+        {
-        }
+            if (!IgnoreCase)
-
+            {
-        private bool DeepEquals(JToken value, JToken input)
+                return JToken.DeepEquals(value, input);
-        {
+            }
-            if (!IgnoreCase)
+
-            {
+            JToken renamedValue = Rename(value);
-                return JToken.DeepEquals(value, input);
+            JToken renamedInput = Rename(input);
-            }
+
-
+            return JToken.DeepEquals(renamedValue, renamedInput);
-            JToken renamedValue = Rename(value);
+        }
-            JToken renamedInput = Rename(input);
+
-
+        private static string ToUpper(string input)
-            return JToken.DeepEquals(renamedValue, renamedInput);
+        {
-        }
+            return input?.ToUpperInvariant();
-
+        }
-        private static string ToUpper(string input)
+
-        {
+        // https://stackoverflow.com/questions/11679804/json-net-rename-properties
-            return input?.ToUpperInvariant();
+        private static JToken Rename(JToken json)
-        }
+        {
-
+            if (json is JProperty property)
-        // https://stackoverflow.com/questions/11679804/json-net-rename-properties
+            {
-        private static JToken Rename(JToken json)
+                JToken propertyValue = property.Value;
-        {
+                if (propertyValue.Type == JTokenType.String)
-            if (json is JProperty property)
+                {
-            {
+                    string stringValue = propertyValue.Value<string>();
-                JToken propertyValue = property.Value;
+                    propertyValue = ToUpper(stringValue);
-                if (propertyValue.Type == JTokenType.String)
+                }
-                {
+
-                    string stringValue = propertyValue.Value<string>();
+                return new JProperty(ToUpper(property.Name), Rename(propertyValue));
-                    propertyValue = ToUpper(stringValue);
+            }
-                }
+
-
+            if (json is JArray array)
-                return new JProperty(ToUpper(property.Name), Rename(propertyValue));
+            {
-            }
+                var renamedValues = array.Select(Rename);
-
+                return new JArray(renamedValues);
-            if (json is JArray array)
+            }
-            {
+
-                var renamedValues = array.Select(Rename);
+            if (json is JObject obj)
-                return new JArray(renamedValues);
+            {
-            }
+                var renamedProperties = obj.Properties().Select(Rename);
-
+                return new JObject(renamedProperties);
-            if (json is JObject obj)
+            }
-            {
+
-                var renamedProperties = obj.Properties().Select(Rename);
+            return json;
-                return new JObject(renamedProperties);
+        }
-            }
+    }
-
-            return json;
-        }
-    }
 }

src/WireMock.Net/Matchers/LinqMatcher.cs

@@ -1,132 +1,140 @@
-using System.Linq;
+using System.Linq;
-using System.Linq.Dynamic.Core;
+using System.Linq.Dynamic.Core;
-using JetBrains.Annotations;
+using JetBrains.Annotations;
-using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Linq;
-using WireMock.Util;
+using WireMock.Util;
-
+
-namespace WireMock.Matchers
+namespace WireMock.Matchers
-{
+{
-    /// <summary>
+    /// <summary>
-    /// System.Linq.Dynamic.Core Expression Matcher
+    /// System.Linq.Dynamic.Core Expression Matcher
-    /// </summary>
+    /// </summary>
-    /// <inheritdoc cref="IObjectMatcher"/>
+    /// <inheritdoc cref="IObjectMatcher"/>
-    /// <inheritdoc cref="IStringMatcher"/>
+    /// <inheritdoc cref="IStringMatcher"/>
-    public class LinqMatcher : IObjectMatcher, IStringMatcher
+    public class LinqMatcher : IObjectMatcher, IStringMatcher
-    {
+    {
-        private readonly string[] _patterns;
+        private readonly string[] _patterns;
-
+
-        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
-        public MatchBehaviour MatchBehaviour { get; }
+        public MatchBehaviour MatchBehaviour { get; }
-
+        /// <inheritdoc cref="IMatcher.ThrowException"/>
-        /// <summary>
+        public bool ThrowException { get; }
-        /// Initializes a new instance of the <see cref="LinqMatcher"/> class.
+
-        /// </summary>
+        /// <summary>
-        /// <param name="pattern">The pattern.</param>
+        /// Initializes a new instance of the <see cref="LinqMatcher"/> class.
-        public LinqMatcher([NotNull] string pattern) : this(new[] { pattern })
+        /// </summary>
-        {
+        /// <param name="pattern">The pattern.</param>
-        }
+        public LinqMatcher([NotNull] string pattern) : this(new[] { pattern })
-
+        {
-        /// <summary>
+        }
-        /// Initializes a new instance of the <see cref="LinqMatcher"/> class.
+
-        /// </summary>
+        /// <summary>
-        /// <param name="patterns">The patterns.</param>
+        /// Initializes a new instance of the <see cref="LinqMatcher"/> class.
-        public LinqMatcher([NotNull] string[] patterns) : this(MatchBehaviour.AcceptOnMatch, patterns)
+        /// </summary>
-        {
+        /// <param name="patterns">The patterns.</param>
-        }
+        public LinqMatcher([NotNull] params string[] patterns) : this(MatchBehaviour.AcceptOnMatch, false, patterns)
-
+        {
-        /// <summary>
+        }
-        /// Initializes a new instance of the <see cref="LinqMatcher"/> class.
+
-        /// </summary>
+        /// <summary>
-        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// Initializes a new instance of the <see cref="LinqMatcher"/> class.
-        /// <param name="pattern">The pattern.</param>
+        /// </summary>
-        public LinqMatcher(MatchBehaviour matchBehaviour, [NotNull] string pattern) : this(matchBehaviour, new[] { pattern })
+        /// <param name="matchBehaviour">The match behaviour.</param>
-        {
+        /// <param name="pattern">The pattern.</param>
-        }
+        public LinqMatcher(MatchBehaviour matchBehaviour, [NotNull] string pattern) : this(matchBehaviour, false, pattern)
-
+        {
-        /// <summary>
+        }
-        /// Initializes a new instance of the <see cref="LinqMatcher"/> class.
+
-        /// </summary>
+        /// <summary>
-        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// Initializes a new instance of the <see cref="LinqMatcher"/> class.
-        /// <param name="patterns">The patterns.</param>
+        /// </summary>
-        public LinqMatcher(MatchBehaviour matchBehaviour, [NotNull] string[] patterns)
+        /// <param name="matchBehaviour">The match behaviour.</param>
-        {
+        /// <param name="patterns">The patterns.</param>
-            MatchBehaviour = matchBehaviour;
+        /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-            _patterns = patterns;
+        public LinqMatcher(MatchBehaviour matchBehaviour, bool throwException = false, [NotNull] params string[] patterns)
-        }
+        {
-
+            MatchBehaviour = matchBehaviour;
-        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
+            ThrowException = throwException;
-        public double IsMatch(string input)
+            _patterns = patterns;
-        {
+        }
-            double match = MatchScores.Mismatch;
+
-
+        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
-            // Convert a single input string to a Queryable string-list with 1 entry.
+        public double IsMatch(string input)
-            IQueryable queryable = new[] { input }.AsQueryable();
+        {
-
+            double match = MatchScores.Mismatch;
-            try
+
-            {
+            // Convert a single input string to a Queryable string-list with 1 entry.
-                // Use the Any(...) method to check if the result matches
+            IQueryable queryable = new[] { input }.AsQueryable();
-                match = MatchScores.ToScore(_patterns.Select(pattern => queryable.Any(pattern)));
+
-
+            try
-                return MatchBehaviourHelper.Convert(MatchBehaviour, match);
+            {
-            }
+                // Use the Any(...) method to check if the result matches
-            catch
+                match = MatchScores.ToScore(_patterns.Select(pattern => queryable.Any(pattern)));
-            {
+
-                // just ignore exception
+                return MatchBehaviourHelper.Convert(MatchBehaviour, match);
-                // TODO add logging?
+            }
-            }
+            catch
-
+            {
-            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
+                if (ThrowException)
-        }
+                {
-
+                    throw;
-        /// <inheritdoc cref="IObjectMatcher.IsMatch"/>
+                }
-        public double IsMatch(object input)
+            }
-        {
+
-            double match = MatchScores.Mismatch;
+            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
-
+        }
-            JObject value;
+
-            switch (input)
+        /// <inheritdoc cref="IObjectMatcher.IsMatch"/>
-            {
+        public double IsMatch(object input)
-                case JObject valueAsJObject:
+        {
-                    value = valueAsJObject;
+            double match = MatchScores.Mismatch;
-                    break;
+
-
+            JObject value;
-                default:
+            switch (input)
-                    value = JObject.FromObject(input);
+            {
-                    break;
+                case JObject valueAsJObject:
-            }
+                    value = valueAsJObject;
-
+                    break;
-            // Convert a single object to a Queryable JObject-list with 1 entry.
+
-            var queryable1 = new[] { value }.AsQueryable();
+                default:
-
+                    value = JObject.FromObject(input);
-            try
+                    break;
-            {
+            }
-                // Generate the DynamicLinq select statement.
+
-                string dynamicSelect = JsonUtils.GenerateDynamicLinqStatement(value);
+            // Convert a single object to a Queryable JObject-list with 1 entry.
-
+            var queryable1 = new[] { value }.AsQueryable();
-                // Execute DynamicLinq Select statement.
+
-                var queryable2 = queryable1.Select(dynamicSelect);
+            try
-
+            {
-                // Use the Any(...) method to check if the result matches.
+                // Generate the DynamicLinq select statement.
-                match = MatchScores.ToScore(_patterns.Select(pattern => queryable2.Any(pattern)));
+                string dynamicSelect = JsonUtils.GenerateDynamicLinqStatement(value);
-
+
-                return MatchBehaviourHelper.Convert(MatchBehaviour, match);
+                // Execute DynamicLinq Select statement.
-            }
+                var queryable2 = queryable1.Select(dynamicSelect);
-            catch
+
-            {
+                // Use the Any(...) method to check if the result matches.
-                // just ignore exception
+                match = MatchScores.ToScore(_patterns.Select(pattern => queryable2.Any(pattern)));
-                // TODO add logging?
+
-            }
+                return MatchBehaviourHelper.Convert(MatchBehaviour, match);
-
+            }
-            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
+            catch
-        }
+            {
-
+                if (ThrowException)
-        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
+                {
-        public string[] GetPatterns()
+                    throw;
-        {
+                }
-            return _patterns;
+            }
-        }
+
-
+            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
-        /// <inheritdoc cref="IMatcher.Name"/>
+        }
-        public string Name => "LinqMatcher";
+
-    }
+        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
-}
+        public string[] GetPatterns()
+        {
+            return _patterns;
+        }
+
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public string Name => "LinqMatcher";
+    }
+}

src/WireMock.Net/Matchers/RegexMatcher.cs

@@ -19,6 +19,9 @@ namespace WireMock.Matchers
         /// <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>
@@ -53,13 +56,15 @@ namespace WireMock.Matchers
         /// <param name="matchBehaviour">The match behaviour.</param>
         /// <param name="patterns">The patterns.</param>
         /// <param name="ignoreCase">Ignore the case from the pattern.</param>
-        public RegexMatcher(MatchBehaviour matchBehaviour, [NotNull, RegexPattern] string[] patterns, bool ignoreCase = false)
+        /// <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;
 
@@ -83,10 +88,13 @@ namespace WireMock.Matchers
                 }
                 catch (Exception)
                 {
-                    // just ignore exception
+                    if (ThrowException)
+                    {
+                        throw;
+                    }
                 }
-            }
+            }
-            
+
             return MatchBehaviourHelper.Convert(MatchBehaviour, match);
         }
 

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

@@ -51,7 +51,7 @@ namespace WireMock.Matchers.Request
         /// <param name="key">The key.</param>
         /// <param name="ignoreCase">Defines if the key should be matched using case-ignore.</param>
         /// <param name="values">The values.</param>
-        public RequestMessageParamMatcher(MatchBehaviour matchBehaviour, [NotNull] string key, bool ignoreCase, [CanBeNull] string[] values) : this(matchBehaviour, key, ignoreCase, values?.Select(value => new ExactMatcher(matchBehaviour, value)).Cast<IStringMatcher>().ToArray())
+        public RequestMessageParamMatcher(MatchBehaviour matchBehaviour, [NotNull] string key, bool ignoreCase, [CanBeNull] string[] values) : this(matchBehaviour, key, ignoreCase, values?.Select(value => new ExactMatcher(matchBehaviour, false, value)).Cast<IStringMatcher>().ToArray())
         {
         }
 

src/WireMock.Net/Matchers/SimMetricsMatcher.cs

@@ -1,125 +1,131 @@
-using System.Linq;
+using System.Linq;
-using JetBrains.Annotations;
+using JetBrains.Annotations;
-using SimMetrics.Net;
+using SimMetrics.Net;
-using SimMetrics.Net.API;
+using SimMetrics.Net.API;
-using SimMetrics.Net.Metric;
+using SimMetrics.Net.Metric;
-using WireMock.Validation;
+using WireMock.Validation;
-
+
-namespace WireMock.Matchers
+namespace WireMock.Matchers
-{
+{
-    /// <summary>
+    /// <summary>
-    /// SimMetricsMatcher
+    /// SimMetricsMatcher
-    /// </summary>
+    /// </summary>
-    /// <seealso cref="IStringMatcher" />
+    /// <seealso cref="IStringMatcher" />
-    public class SimMetricsMatcher : IStringMatcher
+    public class SimMetricsMatcher : IStringMatcher
-    {
+    {
-        private readonly string[] _patterns;
+        private readonly string[] _patterns;
-        private readonly SimMetricType _simMetricType;
+        private readonly SimMetricType _simMetricType;
-
+
-        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
-        public MatchBehaviour MatchBehaviour { get; }
+        public MatchBehaviour MatchBehaviour { get; }
-
+
-        /// <summary>
+        /// <inheritdoc cref="IMatcher.ThrowException"/>
-        /// Initializes a new instance of the <see cref="SimMetricsMatcher"/> class.
+        public bool ThrowException { get; }
-        /// </summary>
+
-        /// <param name="pattern">The pattern.</param>
+        /// <summary>
-        /// <param name="simMetricType">The SimMetric Type</param>
+        /// Initializes a new instance of the <see cref="SimMetricsMatcher"/> class.
-        public SimMetricsMatcher([NotNull] string pattern, SimMetricType simMetricType = SimMetricType.Levenstein) : this(new[] { pattern }, simMetricType)
+        /// </summary>
-        {
+        /// <param name="pattern">The pattern.</param>
-        }
+        /// <param name="simMetricType">The SimMetric Type</param>
-
+        public SimMetricsMatcher([NotNull] string pattern, SimMetricType simMetricType = SimMetricType.Levenstein) : this(new[] { pattern }, simMetricType)
-        /// <summary>
+        {
-        /// Initializes a new instance of the <see cref="SimMetricsMatcher"/> class.
+        }
-        /// </summary>
+
-        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <summary>
-        /// <param name="pattern">The pattern.</param>
+        /// Initializes a new instance of the <see cref="SimMetricsMatcher"/> class.
-        /// <param name="simMetricType">The SimMetric Type</param>
+        /// </summary>
-        public SimMetricsMatcher(MatchBehaviour matchBehaviour, [NotNull] string pattern, SimMetricType simMetricType = SimMetricType.Levenstein) : this(matchBehaviour, new[] { pattern }, simMetricType)
+        /// <param name="matchBehaviour">The match behaviour.</param>
-        {
+        /// <param name="pattern">The pattern.</param>
-        }
+        /// <param name="simMetricType">The SimMetric Type</param>
-
+        public SimMetricsMatcher(MatchBehaviour matchBehaviour, [NotNull] string pattern, SimMetricType simMetricType = SimMetricType.Levenstein) : this(matchBehaviour, new[] { pattern }, simMetricType)
-        /// <summary>
+        {
-        /// Initializes a new instance of the <see cref="SimMetricsMatcher"/> class.
+        }
-        /// </summary>
+
-        /// <param name="patterns">The patterns.</param>
+        /// <summary>
-        /// <param name="simMetricType">The SimMetric Type</param>
+        /// Initializes a new instance of the <see cref="SimMetricsMatcher"/> class.
-        public SimMetricsMatcher([NotNull] string[] patterns, SimMetricType simMetricType = SimMetricType.Levenstein) : this(MatchBehaviour.AcceptOnMatch, patterns, simMetricType)
+        /// </summary>
-        {
+        /// <param name="patterns">The patterns.</param>
-        }
+        /// <param name="simMetricType">The SimMetric Type</param>
-
+        public SimMetricsMatcher([NotNull] string[] patterns, SimMetricType simMetricType = SimMetricType.Levenstein) : this(MatchBehaviour.AcceptOnMatch, patterns, simMetricType)
-        /// <summary>
+        {
-        /// Initializes a new instance of the <see cref="SimMetricsMatcher"/> class.
+        }
-        /// </summary>
+
-        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <summary>
-        /// <param name="patterns">The patterns.</param>
+        /// Initializes a new instance of the <see cref="SimMetricsMatcher"/> class.
-        /// <param name="simMetricType">The SimMetric Type</param>
+        /// </summary>
-        public SimMetricsMatcher(MatchBehaviour matchBehaviour, [NotNull] string[] patterns, SimMetricType simMetricType = SimMetricType.Levenstein)
+        /// <param name="matchBehaviour">The match behaviour.</param>
-        {
+        /// <param name="patterns">The patterns.</param>
-            Check.NotNullOrEmpty(patterns, nameof(patterns));
+        /// <param name="simMetricType">The SimMetric Type</param>
-
+        /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-            MatchBehaviour = matchBehaviour;
+        public SimMetricsMatcher(MatchBehaviour matchBehaviour, [NotNull] string[] patterns, SimMetricType simMetricType = SimMetricType.Levenstein, bool throwException = false)
-            _patterns = patterns;
+        {
-            _simMetricType = simMetricType;
+            Check.NotNullOrEmpty(patterns, nameof(patterns));
-        }
+
-
+            MatchBehaviour = matchBehaviour;
-        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
+            ThrowException = throwException;
-        public double IsMatch(string input)
+
-        {
+            _patterns = patterns;
-            IStringMetric m = GetStringMetricType();
+            _simMetricType = simMetricType;
-
+        }
-            return MatchBehaviourHelper.Convert(MatchBehaviour, MatchScores.ToScore(_patterns.Select(p => m.GetSimilarity(p, input))));
+
-        }
+        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
-
+        public double IsMatch(string input)
-        private IStringMetric GetStringMetricType()
+        {
-        {
+            IStringMetric m = GetStringMetricType();
-            switch (_simMetricType)
+
-            {
+            return MatchBehaviourHelper.Convert(MatchBehaviour, MatchScores.ToScore(_patterns.Select(p => m.GetSimilarity(p, input))));
-                case SimMetricType.BlockDistance:
+        }
-                    return new BlockDistance();
+
-                case SimMetricType.ChapmanLengthDeviation:
+        private IStringMetric GetStringMetricType()
-                    return new ChapmanLengthDeviation();
+        {
-                case SimMetricType.CosineSimilarity:
+            switch (_simMetricType)
-                    return new CosineSimilarity();
+            {
-                case SimMetricType.DiceSimilarity:
+                case SimMetricType.BlockDistance:
-                    return new DiceSimilarity();
+                    return new BlockDistance();
-                case SimMetricType.EuclideanDistance:
+                case SimMetricType.ChapmanLengthDeviation:
-                    return new EuclideanDistance();
+                    return new ChapmanLengthDeviation();
-                case SimMetricType.JaccardSimilarity:
+                case SimMetricType.CosineSimilarity:
-                    return new JaccardSimilarity();
+                    return new CosineSimilarity();
-                case SimMetricType.Jaro:
+                case SimMetricType.DiceSimilarity:
-                    return new Jaro();
+                    return new DiceSimilarity();
-                case SimMetricType.JaroWinkler:
+                case SimMetricType.EuclideanDistance:
-                    return new JaroWinkler();
+                    return new EuclideanDistance();
-                case SimMetricType.MatchingCoefficient:
+                case SimMetricType.JaccardSimilarity:
-                    return new MatchingCoefficient();
+                    return new JaccardSimilarity();
-                case SimMetricType.MongeElkan:
+                case SimMetricType.Jaro:
-                    return new MongeElkan();
+                    return new Jaro();
-                case SimMetricType.NeedlemanWunch:
+                case SimMetricType.JaroWinkler:
-                    return new NeedlemanWunch();
+                    return new JaroWinkler();
-                case SimMetricType.OverlapCoefficient:
+                case SimMetricType.MatchingCoefficient:
-                    return new OverlapCoefficient();
+                    return new MatchingCoefficient();
-                case SimMetricType.QGramsDistance:
+                case SimMetricType.MongeElkan:
-                    return new QGramsDistance();
+                    return new MongeElkan();
-                case SimMetricType.SmithWaterman:
+                case SimMetricType.NeedlemanWunch:
-                    return new SmithWaterman();
+                    return new NeedlemanWunch();
-                case SimMetricType.SmithWatermanGotoh:
+                case SimMetricType.OverlapCoefficient:
-                    return new SmithWatermanGotoh();
+                    return new OverlapCoefficient();
-                case SimMetricType.SmithWatermanGotohWindowedAffine:
+                case SimMetricType.QGramsDistance:
-                    return new SmithWatermanGotohWindowedAffine();
+                    return new QGramsDistance();
-                case SimMetricType.ChapmanMeanLength:
+                case SimMetricType.SmithWaterman:
-                    return new ChapmanMeanLength();
+                    return new SmithWaterman();
-                default:
+                case SimMetricType.SmithWatermanGotoh:
-                    return new Levenstein();
+                    return new SmithWatermanGotoh();
-            }
+                case SimMetricType.SmithWatermanGotohWindowedAffine:
-        }
+                    return new SmithWatermanGotohWindowedAffine();
-
+                case SimMetricType.ChapmanMeanLength:
-        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
+                    return new ChapmanMeanLength();
-        public string[] GetPatterns()
+                default:
-        {
+                    return new Levenstein();
-            return _patterns;
+            }
-        }
+        }
-
+
-        /// <inheritdoc cref="IMatcher.Name"/>
+        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
-        public string Name => $"SimMetricsMatcher.{_simMetricType}";
+        public string[] GetPatterns()
-    }
+        {
+            return _patterns;
+        }
+
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public string Name => $"SimMetricsMatcher.{_simMetricType}";
+    }
 }

src/WireMock.Net/Matchers/WildcardMatcher.cs

@@ -1,63 +1,65 @@
-using System.Linq;
+using System.Linq;
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
-using JetBrains.Annotations;
+using JetBrains.Annotations;
-
+
-namespace WireMock.Matchers
+namespace WireMock.Matchers
-{
+{
-    /// <summary>
+    /// <summary>
-    /// WildcardMatcher
+    /// WildcardMatcher
-    /// </summary>
+    /// </summary>
-    /// <seealso cref="RegexMatcher" />
+    /// <seealso cref="RegexMatcher" />
-    public class WildcardMatcher : RegexMatcher
+    public class WildcardMatcher : RegexMatcher
-    {
+    {
-        private readonly string[] _patterns;
+        private readonly string[] _patterns;
-
+
-        /// <summary>
+        /// <summary>
-        /// Initializes a new instance of the <see cref="WildcardMatcher"/> class.
+        /// Initializes a new instance of the <see cref="WildcardMatcher"/> class.
-        /// </summary>
+        /// </summary>
-        /// <param name="pattern">The pattern.</param>
+        /// <param name="pattern">The pattern.</param>
-        /// <param name="ignoreCase">IgnoreCase</param>
+        /// <param name="ignoreCase">IgnoreCase</param>
-        public WildcardMatcher([NotNull] string pattern, bool ignoreCase = false) : this(new[] { pattern }, ignoreCase)
+        public WildcardMatcher([NotNull] string pattern, bool ignoreCase = false) : this(new[] { pattern }, ignoreCase)
-        {
+        {
-        }
+        }
-
+
-        /// <summary>
+        /// <summary>
-        /// Initializes a new instance of the <see cref="WildcardMatcher"/> class.
+        /// Initializes a new instance of the <see cref="WildcardMatcher"/> class.
-        /// </summary>
+        /// </summary>
-        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="matchBehaviour">The match behaviour.</param>
-        /// <param name="pattern">The pattern.</param>
+        /// <param name="pattern">The pattern.</param>
-        /// <param name="ignoreCase">IgnoreCase</param>
+        /// <param name="ignoreCase">IgnoreCase</param>
-        public WildcardMatcher(MatchBehaviour matchBehaviour, [NotNull] string pattern, bool ignoreCase = false) : this(matchBehaviour, new[] { pattern }, ignoreCase)
+        public WildcardMatcher(MatchBehaviour matchBehaviour, [NotNull] string pattern, bool ignoreCase = false) : this(matchBehaviour, new[] { pattern }, ignoreCase)
-        {
+        {
-        }
+        }
-
+
-        /// <summary>
+        /// <summary>
-        /// Initializes a new instance of the <see cref="WildcardMatcher"/> class.
+        /// Initializes a new instance of the <see cref="WildcardMatcher"/> class.
-        /// </summary>
+        /// </summary>
-        /// <param name="patterns">The patterns.</param>
+        /// <param name="patterns">The patterns.</param>
-        /// <param name="ignoreCase">IgnoreCase</param>
+        /// <param name="ignoreCase">IgnoreCase</param>
-        public WildcardMatcher([NotNull] string[] patterns, bool ignoreCase = false) : this(MatchBehaviour.AcceptOnMatch, patterns, ignoreCase)
+        public WildcardMatcher([NotNull] string[] patterns, bool ignoreCase = false) : this(MatchBehaviour.AcceptOnMatch, patterns, ignoreCase)
-        {
+        {
-        }
+        }
-
+
-        /// <summary>
+        /// <summary>
-        /// Initializes a new instance of the <see cref="WildcardMatcher"/> class.
+        /// Initializes a new instance of the <see cref="WildcardMatcher"/> class.
-        /// </summary>
+        /// </summary>
-        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="matchBehaviour">The match behaviour.</param>
-        /// <param name="patterns">The patterns.</param>
+        /// <param name="patterns">The patterns.</param>
-        /// <param name="ignoreCase">IgnoreCase</param>
+        /// <param name="ignoreCase">IgnoreCase</param>
-        public WildcardMatcher(MatchBehaviour matchBehaviour, [NotNull] string[] patterns, bool ignoreCase = false) : base(matchBehaviour, patterns.Select(pattern => "^" + Regex.Escape(pattern).Replace(@"\*", ".*").Replace(@"\?", ".") + "$").ToArray(), ignoreCase)
+        /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-        {
+        public WildcardMatcher(MatchBehaviour matchBehaviour, [NotNull] string[] patterns, bool ignoreCase = false, bool throwException = false) : 
-            _patterns = patterns;
+            base(matchBehaviour, patterns.Select(pattern => "^" + Regex.Escape(pattern).Replace(@"\*", ".*").Replace(@"\?", ".") + "$").ToArray(), ignoreCase, throwException)
-        }
+        {
-
+            _patterns = patterns;
-        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
+        }
-        public override string[] GetPatterns()
+
-        {
+        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
-            return _patterns;
+        public override string[] GetPatterns()
-        }
+        {
-
+            return _patterns;
-        /// <inheritdoc cref="IMatcher.Name"/>
+        }
-        public override string Name => "WildcardMatcher";
+
-    }
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public override string Name => "WildcardMatcher";
+    }
 }

src/WireMock.Net/Matchers/XPathMatcher.cs

@@ -1,78 +1,85 @@
-using System;
+using System;
-using System.Linq;
+using System.Linq;
-using System.Xml;
+using System.Xml;
-using JetBrains.Annotations;
+using JetBrains.Annotations;
-using WireMock.Validation;
+using WireMock.Validation;
-#if !NETSTANDARD1_3
+#if !NETSTANDARD1_3
-using Wmhelp.XPath2;
+using Wmhelp.XPath2;
-#endif
+#endif
-
+
-namespace WireMock.Matchers
+namespace WireMock.Matchers
-{
+{
-    /// <summary>
+    /// <summary>
-    /// XPath2Matcher
+    /// XPath2Matcher
-    /// </summary>
+    /// </summary>
-    /// <seealso cref="IStringMatcher" />
+    /// <seealso cref="IStringMatcher" />
-    public class XPathMatcher : IStringMatcher
+    public class XPathMatcher : IStringMatcher
-    {
+    {
-        private readonly string[] _patterns;
+        private readonly string[] _patterns;
-
+
-        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
-        public MatchBehaviour MatchBehaviour { get; }
+        public MatchBehaviour MatchBehaviour { get; }
-
+
-        /// <summary>
+        /// <inheritdoc cref="IMatcher.ThrowException"/>
-        /// Initializes a new instance of the <see cref="XPathMatcher"/> class.
+        public bool ThrowException { get; }
-        /// </summary>
+
-        /// <param name="patterns">The patterns.</param>
+        /// <summary>
-        public XPathMatcher([NotNull] params string[] patterns) : this(MatchBehaviour.AcceptOnMatch, patterns)
+        /// Initializes a new instance of the <see cref="XPathMatcher"/> class.
-        {
+        /// </summary>
-        }
+        /// <param name="patterns">The patterns.</param>
-
+        public XPathMatcher([NotNull] params string[] patterns) : this(MatchBehaviour.AcceptOnMatch, false, patterns)
-        /// <summary>
+        {
-        /// Initializes a new instance of the <see cref="XPathMatcher"/> class.
+        }
-        /// </summary>
+
-        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <summary>
-        /// <param name="patterns">The patterns.</param>
+        /// Initializes a new instance of the <see cref="XPathMatcher"/> class.
-        public XPathMatcher(MatchBehaviour matchBehaviour, [NotNull] params string[] patterns)
+        /// </summary>
-        {
+        /// <param name="matchBehaviour">The match behaviour.</param>
-            Check.NotNull(patterns, nameof(patterns));
+        /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-
+        /// <param name="patterns">The patterns.</param>
-            MatchBehaviour = matchBehaviour;
+        public XPathMatcher(MatchBehaviour matchBehaviour, bool throwException = false, [NotNull] params string[] patterns)
-            _patterns = patterns;
+        {
-        }
+            Check.NotNull(patterns, nameof(patterns));
-
+
-        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
+            MatchBehaviour = matchBehaviour;
-        public double IsMatch(string input)
+            ThrowException = throwException;
-        {
+            _patterns = patterns;
-            double match = MatchScores.Mismatch;
+        }
-            if (input != null)
+
-            {
+        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
-                try
+        public double IsMatch(string input)
-                {
+        {
-                    var nav = new XmlDocument { InnerXml = input }.CreateNavigator();
+            double match = MatchScores.Mismatch;
-#if NETSTANDARD1_3
+            if (input != null)
-                    match = MatchScores.ToScore(_patterns.Select(p => true.Equals(nav.Evaluate($"boolean({p})"))));
+            {
-#else
+                try
-                    match = MatchScores.ToScore(_patterns.Select(p => true.Equals(nav.XPath2Evaluate($"boolean({p})"))));
+                {
-#endif
+                    var nav = new XmlDocument { InnerXml = input }.CreateNavigator();
-                }
+#if NETSTANDARD1_3
-                catch (Exception)
+                    match = MatchScores.ToScore(_patterns.Select(p => true.Equals(nav.Evaluate($"boolean({p})"))));
-                {
+#else
-                    // just ignore exception
+                    match = MatchScores.ToScore(_patterns.Select(p => true.Equals(nav.XPath2Evaluate($"boolean({p})"))));
-                    // TODO add logging?
+#endif
-                }
+                }
-            }
+                catch (Exception)
-
+                {
-            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
+                    if (ThrowException)
-        }
+                    {
-
+                        throw;
-        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
+                    }
-        public string[] GetPatterns()
+                }
-        {
+            }
-            return _patterns;
+
-        }
+            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
-
+        }
-        /// <inheritdoc cref="IMatcher.Name"/>
+
-        public string Name => "XPathMatcher";
+        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
-    }
+        public string[] GetPatterns()
+        {
+            return _patterns;
+        }
+
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public string Name => "XPathMatcher";
+    }
 }

src/WireMock.Net/Owin/IWireMockMiddlewareOptions.cs

@@ -45,5 +45,7 @@ namespace WireMock.Owin
         bool? DisableJsonBodyParsing { get; set; }
 
         bool? DisableRequestBodyDecompressing { get; set; }
+
+        bool? HandleRequestsSynchronously { get; set; }
     }
 }

src/WireMock.Net/Owin/Mappers/OwinResponseMapper.cs

@@ -7,8 +7,6 @@ using System.Threading.Tasks;
 using Newtonsoft.Json;
 using RandomDataGenerator.FieldOptions;
 using RandomDataGenerator.Randomizers;
-using WireMock.Exceptions;
-using WireMock.Handlers;
 using WireMock.Http;
 using WireMock.ResponseBuilders;
 using WireMock.Types;

src/WireMock.Net/Owin/MappingMatcher.cs

@@ -23,12 +23,12 @@ namespace WireMock.Owin
             {
                 try
                 {
-                    string scenario = mapping.Scenario != null && _options.Scenarios.ContainsKey(mapping.Scenario) ? _options.Scenarios[mapping.Scenario].NextState : null;
+                    string nextState = GetNextState(mapping);
 
                     mappings.Add(new MappingMatcherResult
                     {
                         Mapping = mapping,
-                        RequestMatchResult = mapping.GetRequestMatchResult(request, scenario)
+                        RequestMatchResult = mapping.GetRequestMatchResult(request, nextState)
                     });
                 }
                 catch (Exception ex)
@@ -56,5 +56,18 @@ namespace WireMock.Owin
 
             return (match, partialMatch);
         }
+
+        private string GetNextState(IMapping mapping)
+        {
+            // If the mapping does not have a scenario or _options.Scenarios does not contain this scenario from the mapping,
+            // just return null to indicate that there is no next state.
+            if (mapping.Scenario == null || !_options.Scenarios.ContainsKey(mapping.Scenario))
+            {
+                return null;
+            }
+
+            // Else just return the next state
+            return _options.Scenarios[mapping.Scenario].NextState;
+        }
     }
 }

src/WireMock.Net/Owin/WireMockMiddleware.cs

@@ -2,9 +2,7 @@ using System;
 using System.Threading.Tasks;
 using WireMock.Logging;
 using System.Linq;
-using System.Text.RegularExpressions;
 using WireMock.Matchers;
-using Newtonsoft.Json;
 using WireMock.Http;
 using WireMock.Owin.Mappers;
 using WireMock.Serialization;
@@ -25,6 +23,7 @@ namespace WireMock.Owin
 {
     internal class WireMockMiddleware : OwinMiddleware
     {
+        private readonly object _lock = new object();
         private static readonly Task CompletedTask = Task.FromResult(false);
         private readonly IWireMockMiddlewareOptions _options;
         private readonly IOwinRequestMapper _requestMapper;
@@ -65,7 +64,17 @@ namespace WireMock.Owin
         public Task Invoke(IContext ctx)
 #endif
         {
-            return InvokeInternal(ctx);
+            if (_options.HandleRequestsSynchronously.GetValueOrDefault(true))
+            {
+                lock (_lock)
+                {
+                    return InvokeInternal(ctx);
+                }
+            }
+            else
+            {
+                return InvokeInternal(ctx);
+            }
         }
 
         private async Task InvokeInternal(IContext ctx)
@@ -79,7 +88,7 @@ namespace WireMock.Owin
             {
                 foreach (var mapping in _options.Mappings.Values.Where(m => m?.Scenario != null))
                 {
-                    // Set start
+                    // Set scenario start
                     if (!_options.Scenarios.ContainsKey(mapping.Scenario) && mapping.IsStartState)
                     {
                         _options.Scenarios.TryAdd(mapping.Scenario, new ScenarioState
@@ -122,9 +131,7 @@ namespace WireMock.Owin
 
                 if (targetMapping.Scenario != null)
                 {
-                    _options.Scenarios[targetMapping.Scenario].NextState = targetMapping.NextState;
+                    UpdateScenarioState(targetMapping);
-                    _options.Scenarios[targetMapping.Scenario].Started = true;
-                    _options.Scenarios[targetMapping.Scenario].Finished = targetMapping.NextState == null;
                 }
             }
             catch (Exception ex)
@@ -157,6 +164,25 @@ namespace WireMock.Owin
             await CompletedTask;
         }
 
+        private void UpdateScenarioState(IMapping mapping)
+        {
+            var scenario = _options.Scenarios[mapping.Scenario];
+
+            // Increase the number of times this state has been executed
+            scenario.Counter++;
+
+            // Only if the number of times this state is executed equals the required StateTimes, proceed to next state and reset the counter to 0
+            if (scenario.Counter == (mapping.StateTimes ?? 1))
+            {
+                scenario.NextState = mapping.NextState;
+                scenario.Counter = 0;
+            }
+
+            // Else just update Started and Finished
+            scenario.Started = true;
+            scenario.Finished = mapping.NextState == null;
+        }
+
         private void LogRequest(LogEntry entry, bool addRequest)
         {
             _options.Logger.DebugRequestResponse(LogEntryMapper.Map(entry), entry.RequestMessage.Path.StartsWith("/__admin/"));

src/WireMock.Net/Owin/WireMockMiddlewareOptions.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Concurrent;
-using System.Collections.ObjectModel;
 using WireMock.Handlers;
 using WireMock.Logging;
 using WireMock.Matchers;
@@ -51,5 +50,8 @@ namespace WireMock.Owin
 
         /// <inheritdoc cref="IWireMockMiddlewareOptions.DisableRequestBodyDecompressing"/>
         public bool? DisableRequestBodyDecompressing { get; set; }
+
+        /// <inheritdoc cref="IWireMockMiddlewareOptions.HandleRequestsSynchronously"/>
+        public bool? HandleRequestsSynchronously { get; set; }
     }
 }

src/WireMock.Net/ResponseBuilders/Response.cs

@@ -60,7 +60,7 @@ namespace WireMock.ResponseBuilders
         [PublicAPI]
         public static IResponseBuilder Create([CanBeNull] ResponseMessage responseMessage = null)
         {
-            var message = responseMessage ?? new ResponseMessage(); // { StatusCode = (int)HttpStatusCode.OK };
+            var message = responseMessage ?? new ResponseMessage();
             return new Response(message);
         }
 

src/WireMock.Net/ResponseMessage.cs

@@ -35,21 +35,13 @@ namespace WireMock
         /// <inheritdoc cref="IResponseMessage.FaultPercentage" />
         public double? FaultPercentage { get; set; }
 
-        /// <summary>
+        /// <inheritdoc cref="IResponseMessage.AddHeader(string, string)" />
-        /// Adds the header.
-        /// </summary>
-        /// <param name="name">The name.</param>
-        /// <param name="value">The value.</param>
         public void AddHeader(string name, string value)
         {
             Headers.Add(name, new WireMockList<string>(value));
         }
 
-        /// <summary>
+        /// <inheritdoc cref="IResponseMessage.AddHeader(string, string[])" />
-        /// Adds the header.
-        /// </summary>
-        /// <param name="name">The name.</param>
-        /// <param name="values">The values.</param>
         public void AddHeader(string name, params string[] values)
         {
             Check.NotNullOrEmpty(values, nameof(values));

src/WireMock.Net/ScenarioState.cs

@@ -24,5 +24,10 @@
         /// Gets or sets a value indicating whether this <see cref="ScenarioState"/> is finished.
         /// </summary>
         public bool Finished { get; set; }
+
+        /// <summary>
+        /// Gets or sets the state counter.
+        /// </summary>
+        public int Counter { get; set; }
     }
 }

src/WireMock.Net/Serialization/MatcherMapper.cs

@@ -38,6 +38,8 @@ namespace WireMock.Serialization
 
             string[] stringPatterns = matcher.Patterns != null ? matcher.Patterns.OfType<string>().ToArray() : new[] { matcher.Pattern as string };
             MatchBehaviour matchBehaviour = matcher.RejectOnMatch == true ? MatchBehaviour.RejectOnMatch : MatchBehaviour.AcceptOnMatch;
+            bool ignoreCase = matcher.IgnoreCase == true;
+            bool throwExceptionWhenMatcherFails = _settings.ThrowExceptionWhenMatcherFails == true;
 
             switch (matcherName)
             {
@@ -50,34 +52,34 @@ namespace WireMock.Serialization
                     throw new NotSupportedException("It's not allowed to use the 'CSharpCodeMatcher' because IWireMockServerSettings.AllowCSharpCodeMatcher is not set to 'true'.");
 
                 case "LinqMatcher":
-                    return new LinqMatcher(matchBehaviour, stringPatterns);
+                    return new LinqMatcher(matchBehaviour, throwExceptionWhenMatcherFails, stringPatterns);
 
                 case "ExactMatcher":
-                    return new ExactMatcher(matchBehaviour, stringPatterns);
+                    return new ExactMatcher(matchBehaviour, throwExceptionWhenMatcherFails, stringPatterns);
 
                 case "ExactObjectMatcher":
-                    return CreateExactObjectMatcher(matchBehaviour, stringPatterns[0]);
+                    return CreateExactObjectMatcher(matchBehaviour, stringPatterns[0], throwExceptionWhenMatcherFails);
 
                 case "RegexMatcher":
-                    return new RegexMatcher(matchBehaviour, stringPatterns, matcher.IgnoreCase == true);
+                    return new RegexMatcher(matchBehaviour, stringPatterns, ignoreCase, throwExceptionWhenMatcherFails);
 
                 case "JsonMatcher":
-                    return new JsonMatcher(matchBehaviour, matcher.Pattern, matcher.IgnoreCase == true);
+                    return new JsonMatcher(matchBehaviour, stringPatterns, ignoreCase, throwExceptionWhenMatcherFails);
 
                 case "JsonPathMatcher":
-                    return new JsonPathMatcher(matchBehaviour, stringPatterns);
+                    return new JsonPathMatcher(matchBehaviour, throwExceptionWhenMatcherFails, stringPatterns);
 
                 case "JmesPathMatcher":
-                    return new JmesPathMatcher(matchBehaviour, stringPatterns);
+                    return new JmesPathMatcher(matchBehaviour, throwExceptionWhenMatcherFails, stringPatterns);
 
                 case "XPathMatcher":
-                    return new XPathMatcher(matchBehaviour, stringPatterns);
+                    return new XPathMatcher(matchBehaviour, throwExceptionWhenMatcherFails, stringPatterns);
 
                 case "WildcardMatcher":
-                    return new WildcardMatcher(matchBehaviour, stringPatterns, matcher.IgnoreCase == true);
+                    return new WildcardMatcher(matchBehaviour, stringPatterns, ignoreCase, throwExceptionWhenMatcherFails);
 
                 case "ContentTypeMatcher":
-                    return new ContentTypeMatcher(matchBehaviour, stringPatterns, matcher.IgnoreCase == true);
+                    return new ContentTypeMatcher(matchBehaviour, stringPatterns, ignoreCase, throwExceptionWhenMatcherFails);
 
                 case "SimMetricsMatcher":
                     SimMetricType type = SimMetricType.Levenstein;
@@ -86,28 +88,13 @@ namespace WireMock.Serialization
                         throw new NotSupportedException($"Matcher '{matcherName}' with Type '{matcherType}' is not supported.");
                     }
 
-                    return new SimMetricsMatcher(matchBehaviour, stringPatterns, type);
+                    return new SimMetricsMatcher(matchBehaviour, stringPatterns, type, throwExceptionWhenMatcherFails);
 
                 default:
                     throw new NotSupportedException($"Matcher '{matcherName}' is not supported.");
             }
         }
 
-        private ExactObjectMatcher CreateExactObjectMatcher(MatchBehaviour matchBehaviour, string stringPattern)
-        {
-            byte[] bytePattern;
-            try
-            {
-                bytePattern = Convert.FromBase64String(stringPattern);
-            }
-            catch
-            {
-                throw new ArgumentException($"Matcher 'ExactObjectMatcher' has invalid pattern. The pattern value '{stringPattern}' is not a Base64String.", nameof(stringPattern));
-            }
-
-            return new ExactObjectMatcher(matchBehaviour, bytePattern);
-        }
-
         public MatcherModel[] Map([CanBeNull] IEnumerable<IMatcher> matchers)
         {
             return matchers?.Select(Map).Where(m => m != null).ToArray();
@@ -152,5 +139,20 @@ namespace WireMock.Serialization
                 Patterns = patterns.Length > 1 ? patterns : null
             };
         }
+
+        private ExactObjectMatcher CreateExactObjectMatcher(MatchBehaviour matchBehaviour, string stringPattern, bool throwException)
+        {
+            byte[] bytePattern;
+            try
+            {
+                bytePattern = Convert.FromBase64String(stringPattern);
+            }
+            catch
+            {
+                throw new ArgumentException($"Matcher 'ExactObjectMatcher' has invalid pattern. The pattern value '{stringPattern}' is not a Base64String.", nameof(stringPattern));
+            }
+
+            return new ExactObjectMatcher(matchBehaviour, bytePattern, throwException);
+        }
     }
 }

src/WireMock.Net/Server/FluentMockServer.cs

@@ -1,11 +0,0 @@
-using WireMock.Settings;
-
-namespace WireMock.Server
-{
-    public class FluentMockServer : WireMockServer
-    {
-        public FluentMockServer(IFluentMockServerSettings settings) : base((IWireMockServerSettings) settings)
-        {
-        }
-    }
-}

src/WireMock.Net/Server/IRespondWithAProvider.cs

@@ -86,14 +86,16 @@ namespace WireMock.Server
         /// Once this mapping is executed the state will be changed to specified one.
         /// </summary>
         /// <param name="state">Any object which identifies the new state</param>
+        /// <param name="times">The number of times this match should be matched before the state will be changed to the specified one. Default value is 1.</param>
         /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
-        IRespondWithAProvider WillSetStateTo(string state);
+        IRespondWithAProvider WillSetStateTo(string state, int? times = 1);
 
         /// <summary>
         /// Once this mapping is executed the state will be changed to specified one.
         /// </summary>
         /// <param name="state">Any object which identifies the new state</param>
+        /// <param name="times">The number of times this match should be matched before the state will be changed to the specified one. Default value is 1.</param>
         /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
-        IRespondWithAProvider WillSetStateTo(int state);
+        IRespondWithAProvider WillSetStateTo(int state, int? times = 1);
     }
 }

src/WireMock.Net/Server/RespondWithAProvider.cs

@@ -18,6 +18,7 @@ namespace WireMock.Server
         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;
@@ -46,7 +47,7 @@ namespace WireMock.Server
         /// <param name="provider">The provider.</param>
         public void RespondWith(IResponseProvider provider)
         {
-            _registrationCallback(new Mapping(Guid, _title, _path, _settings, _requestMatcher, provider, _priority, _scenario, _executionConditionState, _nextState), _saveToFile);
+            _registrationCallback(new Mapping(Guid, _title, _path, _settings, _requestMatcher, provider, _priority, _scenario, _executionConditionState, _nextState, _timesInSameState), _saveToFile);
         }
 
         /// <see cref="IRespondWithAProvider.WithGuid(string)"/>
@@ -120,8 +121,8 @@ namespace WireMock.Server
             return WhenStateIs(state.ToString());
         }
 
-        /// <see cref="IRespondWithAProvider.WillSetStateTo(string)"/>
+        /// <see cref="IRespondWithAProvider.WillSetStateTo(string, int?)"/>
-        public IRespondWithAProvider WillSetStateTo(string state)
+        public IRespondWithAProvider WillSetStateTo(string state, int? times = 1)
         {
             if (string.IsNullOrEmpty(_scenario))
             {
@@ -129,14 +130,15 @@ namespace WireMock.Server
             }
 
             _nextState = state;
+            _timesInSameState = times ?? 1;
 
             return this;
         }
 
-        /// <see cref="IRespondWithAProvider.WillSetStateTo(int)"/>
+        /// <see cref="IRespondWithAProvider.WillSetStateTo(int, int?)"/>
-        public IRespondWithAProvider WillSetStateTo(int state)
+        public IRespondWithAProvider WillSetStateTo(int state, int? times = 1)
         {
-            return WillSetStateTo(state.ToString());
+            return WillSetStateTo(state.ToString(), times);
         }
     }
 }

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

@@ -1,6 +1,3 @@
-using JetBrains.Annotations;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -9,6 +6,9 @@ using System.Net;
 using System.Net.Http;
 using System.Text;
 using System.Threading.Tasks;
+using JetBrains.Annotations;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using WireMock.Admin.Mappings;
 using WireMock.Admin.Scenarios;
 using WireMock.Admin.Settings;
@@ -274,7 +274,12 @@ namespace WireMock.Server
             if (HttpStatusRangeParser.IsMatch(settings.ProxyAndRecordSettings.SaveMappingForStatusCodePattern, responseMessage.StatusCode) &&
                 (settings.ProxyAndRecordSettings.SaveMapping || settings.ProxyAndRecordSettings.SaveMappingToFile))
             {
-                var mapping = ToMapping(requestMessage, responseMessage, settings.ProxyAndRecordSettings.BlackListedHeaders ?? new string[] { }, settings.ProxyAndRecordSettings.BlackListedCookies ?? new string[] { });
+                var mapping = ToMapping(
+                    requestMessage,
+                    responseMessage,
+                    settings.ProxyAndRecordSettings.ExcludedHeaders ?? new string[] { },
+                    settings.ProxyAndRecordSettings.ExcludedCookies ?? new string[] { }
+                );
 
                 if (settings.ProxyAndRecordSettings.SaveMapping)
                 {
@@ -290,7 +295,7 @@ namespace WireMock.Server
             return responseMessage;
         }
 
-        private IMapping ToMapping(RequestMessage requestMessage, ResponseMessage responseMessage, string[] blacklistedHeaders, string[] blacklistedCookies)
+        private IMapping ToMapping(RequestMessage requestMessage, ResponseMessage responseMessage, string[] excludedHeaders, string[] excludedCookies)
         {
             var request = Request.Create();
             request.WithPath(requestMessage.Path);
@@ -299,39 +304,40 @@ namespace WireMock.Server
             requestMessage.Query.Loop((key, value) => request.WithParam(key, false, value.ToArray()));
             requestMessage.Cookies.Loop((key, value) =>
             {
-                if (!blacklistedCookies.Contains(key, StringComparer.OrdinalIgnoreCase))
+                if (!excludedCookies.Contains(key, StringComparer.OrdinalIgnoreCase))
                 {
                     request.WithCookie(key, value);
                 }
             });
 
-            var allBlackListedHeaders = new List<string>(blacklistedHeaders) { "Cookie" };
+            var allExcludedHeaders = new List<string>(excludedHeaders) { "Cookie" };
             requestMessage.Headers.Loop((key, value) =>
             {
-                if (!allBlackListedHeaders.Contains(key, StringComparer.OrdinalIgnoreCase))
+                if (!allExcludedHeaders.Contains(key, StringComparer.OrdinalIgnoreCase))
                 {
                     request.WithHeader(key, value.ToArray());
                 }
             });
 
+            bool throwExceptionWhenMatcherFails = _settings.ThrowExceptionWhenMatcherFails == true;
             switch (requestMessage.BodyData?.DetectedBodyType)
             {
                 case BodyType.Json:
-                    request.WithBody(new JsonMatcher(MatchBehaviour.AcceptOnMatch, requestMessage.BodyData.BodyAsJson));
+                    request.WithBody(new JsonMatcher(MatchBehaviour.AcceptOnMatch, requestMessage.BodyData.BodyAsJson, true, throwExceptionWhenMatcherFails));
                     break;
 
                 case BodyType.String:
-                    request.WithBody(new ExactMatcher(MatchBehaviour.AcceptOnMatch, requestMessage.BodyData.BodyAsString));
+                    request.WithBody(new ExactMatcher(MatchBehaviour.AcceptOnMatch, throwExceptionWhenMatcherFails, requestMessage.BodyData.BodyAsString));
                     break;
 
                 case BodyType.Bytes:
-                    request.WithBody(new ExactObjectMatcher(MatchBehaviour.AcceptOnMatch, requestMessage.BodyData.BodyAsBytes));
+                    request.WithBody(new ExactObjectMatcher(MatchBehaviour.AcceptOnMatch, requestMessage.BodyData.BodyAsBytes, throwExceptionWhenMatcherFails));
                     break;
             }
 
             var response = Response.Create(responseMessage);
 
-            return new Mapping(Guid.NewGuid(), string.Empty, null, _settings, request, response, 0, null, null, null);
+            return new Mapping(Guid.NewGuid(), string.Empty, null, _settings, request, response, 0, null, null, null, null);
         }
         #endregion
 
@@ -340,11 +346,13 @@ namespace WireMock.Server
         {
             var model = new SettingsModel
             {
-                AllowPartialMapping = _options.AllowPartialMapping,
+                AllowPartialMapping = _settings.AllowPartialMapping,
-                MaxRequestLogCount = _options.MaxRequestLogCount,
+                MaxRequestLogCount = _settings.MaxRequestLogCount,
-                RequestLogExpirationDuration = _options.RequestLogExpirationDuration,
+                RequestLogExpirationDuration = _settings.RequestLogExpirationDuration,
                 GlobalProcessingDelay = (int?)_options.RequestProcessingDelay?.TotalMilliseconds,
-                AllowBodyForAllHttpMethods = _options.AllowBodyForAllHttpMethods
+                AllowBodyForAllHttpMethods = _settings.AllowBodyForAllHttpMethods,
+                HandleRequestsSynchronously = _settings.HandleRequestsSynchronously,
+                ThrowExceptionWhenMatcherFails = _settings.ThrowExceptionWhenMatcherFails
             };
 
             return ToJson(model);
@@ -371,6 +379,16 @@ namespace WireMock.Server
                 _options.AllowBodyForAllHttpMethods = settings.AllowBodyForAllHttpMethods.Value;
             }
 
+            if (settings.HandleRequestsSynchronously != null)
+            {
+                _options.HandleRequestsSynchronously = settings.HandleRequestsSynchronously.Value;
+            }
+
+            if (settings.ThrowExceptionWhenMatcherFails != null)
+            {
+                _settings.ThrowExceptionWhenMatcherFails = settings.ThrowExceptionWhenMatcherFails.Value;
+            }
+
             return ResponseMessageBuilder.Create("Settings updated");
         }
         #endregion Settings
@@ -706,7 +724,8 @@ namespace WireMock.Server
                 Name = s.Name,
                 NextState = s.NextState,
                 Started = s.Started,
-                Finished = s.Finished
+                Finished = s.Finished,
+                Counter = s.Counter
             });
 
             return ToJson(scenariosStates, true);
@@ -814,9 +833,9 @@ namespace WireMock.Server
 
             if (requestModel.Params != null)
             {
-                foreach (var paramModel in requestModel.Params.Where(c => c.Matchers != null))
+                foreach (var paramModel in requestModel.Params.Where(p => p != null && p.Matchers != null))
                 {
-                    bool ignoreCase = paramModel?.IgnoreCase ?? false;
+                    bool ignoreCase = paramModel.IgnoreCase == true;
                     requestBuilder = requestBuilder.WithParam(paramModel.Name, ignoreCase, paramModel.Matchers.Select(_matcherMapper.Map).OfType<IStringMatcher>().ToArray());
                 }
             }

src/WireMock.Net/Server/WireMockServer.cs

@@ -184,6 +184,17 @@ namespace WireMock.Server
                 ReadStaticMappings = true
             });
         }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WireMockServer"/> class.
+        /// </summary>
+        /// <param name="settings">The settings.</param>
+        /// <exception cref="WireMockException">
+        /// Service start failed with error: {_httpServer.RunningException.Message}
+        /// or
+        /// Service start failed with error: {startTask.Exception.Message}
+        /// </exception>
+        /// <exception cref="TimeoutException">Service start timed out after {TimeSpan.FromMilliseconds(settings.StartTimeout)}</exception>
         protected WireMockServer(IWireMockServerSettings settings)
         {
             _settings = settings;
@@ -217,6 +228,7 @@ namespace WireMock.Server
             _options.PostWireMockMiddlewareInit = _settings.PostWireMockMiddlewareInit;
             _options.Logger = _settings.Logger;
             _options.DisableJsonBodyParsing = _settings.DisableJsonBodyParsing;
+            _options.HandleRequestsSynchronously = settings.HandleRequestsSynchronously;
 
             _matcherMapper = new MatcherMapper(_settings);
             _mappingConverter = new MappingConverter(_matcherMapper);
@@ -421,7 +433,7 @@ namespace WireMock.Server
         {
             _options.Scenarios.Clear();
         }
-        
+
         /// <inheritdoc cref="IWireMockServer.WithMapping(MappingModel[])" />
         [PublicAPI]
         public IWireMockServer WithMapping(params MappingModel[] mappings)

src/WireMock.Net/Settings/FluentMockServerSettings.cs

@@ -1,9 +0,0 @@
-namespace WireMock.Settings
-{
-    /// <summary>
-    /// FluentMockServerSettings
-    /// </summary>
-    public class FluentMockServerSettings : WireMockServerSettings
-    {
-    }
-}

src/WireMock.Net/Settings/IFluentMockServerSettings.cs

@@ -1,9 +0,0 @@
-namespace WireMock.Settings
-{
-    /// <summary>
-    /// IFluentMockServerSettings
-    /// </summary>
-    public interface IFluentMockServerSettings : IWireMockServerSettings
-    {
-    }
-}

src/WireMock.Net/Settings/IProxyAndRecordSettings.cs

@@ -36,14 +36,14 @@ namespace WireMock.Settings
         string ClientX509Certificate2ThumbprintOrSubjectName { get; set; }
 
         /// <summary>
-        /// Defines a list from headers which will excluded from the saved mappings.
+        /// Defines a list from headers which will be excluded from the saved mappings.
         /// </summary>
-        string[] BlackListedHeaders { get; set; }
+        string[] ExcludedHeaders { get; set; }
 
         /// <summary>
-        /// Defines a list of cookies which will excluded from the saved mappings.
+        /// Defines a list of cookies which will be excluded from the saved mappings.
         /// </summary>
-        string[] BlackListedCookies { get; set; }
+        string[] ExcludedCookies { get; set; }
 
         /// <summary>
         /// Defines the WebProxySettings.

src/WireMock.Net/Settings/IWebProxySettings.cs

@@ -1,5 +1,8 @@
 namespace WireMock.Settings
 {
+    /// <summary>
+    /// IWebProxySettings
+    /// </summary>
     public interface IWebProxySettings
     {
         /// <summary>

src/WireMock.Net/Settings/IWireMockServerSettings.cs

@@ -3,6 +3,7 @@ using HandlebarsDotNet;
 using JetBrains.Annotations;
 using WireMock.Handlers;
 using WireMock.Logging;
+using WireMock.Matchers;
 
 namespace WireMock.Settings
 {
@@ -143,7 +144,7 @@ namespace WireMock.Settings
         /// - false : also null, 0, empty or invalid HttpStatus codes are allowed.
         /// - true  : only codes defined in <see cref="System.Net.HttpStatusCode"/> are allowed.
         /// </summary>
-        /// [PublicAPI]
+        [PublicAPI]
         bool? AllowOnlyDefinedHttpStatusCodeInResponse { get; set; }
 
         /// <summary>
@@ -157,5 +158,17 @@ namespace WireMock.Settings
         /// </summary>
         [PublicAPI]
         bool? DisableRequestBodyDecompressing { get; set; }
+
+        /// <summary>
+        /// Handle all requests synchronously. (default set to false).
+        /// </summary>
+        [PublicAPI]
+        bool? HandleRequestsSynchronously { get; set; }
+
+        /// <summary>
+        /// Throw an exception when the <see cref="IMatcher"/> fails because of invalid input. (default set to false).
+        /// </summary>
+        [PublicAPI]
+        bool? ThrowExceptionWhenMatcherFails { get; set; }
     }
 }

src/WireMock.Net/Settings/ProxyAndRecordSettings.cs

@@ -39,17 +39,13 @@ namespace WireMock.Settings
         [PublicAPI]
         public string ClientX509Certificate2ThumbprintOrSubjectName { get; set; }
 
-        /// <summary>
+        /// <inheritdoc cref="IProxyAndRecordSettings.ExcludedHeaders"/>
-        /// Defines a list from headers which will excluded from the saved mappings.
-        /// </summary>
         [PublicAPI]
-        public string[] BlackListedHeaders { get; set; }
+        public string[] ExcludedHeaders { get; set; }
 
-        /// <summary>
+        /// <inheritdoc cref="IProxyAndRecordSettings.ExcludedCookies"/>
-        /// Defines a list of cookies which will excluded from the saved mappings.
-        /// </summary>
         [PublicAPI]
-        public string[] BlackListedCookies { get; set; }
+        public string[] ExcludedCookies { get; set; }
 
         /// <inheritdoc cref="IProxyAndRecordSettings.WebProxySettings"/>
         [PublicAPI]

src/WireMock.Net/Settings/WebProxySettings.cs

@@ -2,6 +2,7 @@
 
 namespace WireMock.Settings
 {
+    /// <seealso cref="IWebProxySettings" />
     public class WebProxySettings : IWebProxySettings
     {
         /// <inheritdoc cref="IWebProxySettings.Address"/>

src/WireMock.Net/Settings/WireMockServerSettings.cs

@@ -113,5 +113,13 @@ namespace WireMock.Settings
         /// <inheritdoc cref="IWireMockServerSettings.DisableRequestBodyDecompressing"/>
         [PublicAPI]
         public bool? DisableRequestBodyDecompressing { get; set; }
+
+        /// <inheritdoc cref="IWireMockServerSettings.HandleRequestsSynchronously"/>
+        [PublicAPI]
+        public bool? HandleRequestsSynchronously { get; set; }
+
+        /// <inheritdoc cref="IWireMockServerSettings.ThrowExceptionWhenMatcherFails"/>
+        [PublicAPI]
+        public bool? ThrowExceptionWhenMatcherFails { get; set; }
     }
 }

src/WireMock.Net/Settings/WireMockServerSettingsParser.cs

@@ -36,7 +36,9 @@ namespace WireMock.Settings
                 AllowCSharpCodeMatcher = parser.GetBoolValue("AllowCSharpCodeMatcher"),
                 AllowBodyForAllHttpMethods = parser.GetBoolValue("AllowBodyForAllHttpMethods"),
                 AllowOnlyDefinedHttpStatusCodeInResponse = parser.GetBoolValue("AllowOnlyDefinedHttpStatusCodeInResponse"),
-                DisableJsonBodyParsing = parser.GetBoolValue("DisableJsonBodyParsing")
+                DisableJsonBodyParsing = parser.GetBoolValue("DisableJsonBodyParsing"),
+                HandleRequestsSynchronously = parser.GetBoolValue("HandleRequestsSynchronously"),
+                ThrowExceptionWhenMatcherFails = parser.GetBoolValue("ThrowExceptionWhenMatcherFails")
             };
 
             if (logger != null)
@@ -68,8 +70,8 @@ namespace WireMock.Settings
                     SaveMappingToFile = parser.GetBoolValue("SaveMappingToFile"),
                     SaveMappingForStatusCodePattern = parser.GetStringValue("SaveMappingForStatusCodePattern"),
                     ClientX509Certificate2ThumbprintOrSubjectName = parser.GetStringValue("ClientX509Certificate2ThumbprintOrSubjectName"),
-                    BlackListedHeaders = parser.GetValues("BlackListedHeaders"),
+                    ExcludedHeaders = parser.GetValues("ExcludedHeaders"),
-                    BlackListedCookies = parser.GetValues("BlackListedCookies"),
+                    ExcludedCookies = parser.GetValues("ExcludedCookies"),
                     AllowAutoRedirect = parser.GetBoolValue("AllowAutoRedirect")
                 };
 

src/WireMock.Net/Transformers/HandlebarsContextFactory.cs

@@ -1,5 +1,5 @@
-using HandlebarsDotNet;
+using System;
-using System;
+using HandlebarsDotNet;
 using WireMock.Handlers;
 
 namespace WireMock.Transformers

src/WireMock.Net/Transformers/IHandlebarsContextFactory.cs

@@ -1,9 +1,7 @@
-using HandlebarsDotNet;
+namespace WireMock.Transformers
-
-namespace WireMock.Transformers
 {
     interface IHandlebarsContextFactory
     {
         IHandlebarsContext Create();
     }
-}
+}

src/WireMock.Net/Transformers/ResponseMessageTransformer.cs

@@ -1,11 +1,10 @@
-using HandlebarsDotNet;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HandlebarsDotNet;
 using JetBrains.Annotations;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using WireMock.Types;
 using WireMock.Util;
 using WireMock.Validation;

src/WireMock.Net/Validation/Check.cs

@@ -5,7 +5,6 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
-using System.Reflection;
 using JetBrains.Annotations;
 
 // Copied from https://github.com/aspnet/EntityFramework/blob/dev/src/Shared/Check.cs
@@ -96,19 +95,6 @@ namespace WireMock.Validation
             return value;
         }
 
-        //public static string NullButNotEmpty(string value, [InvokerParameterName, ValidatedNotNull, NotNull] string parameterName)
-        //{
-        //    if (!ReferenceEquals(value, null)
-        //        && (value.Length == 0))
-        //    {
-        //        NotNullOrEmpty(parameterName, nameof(parameterName));
-
-        //        throw new ArgumentException(CoreStrings.ArgumentIsEmpty(parameterName));
-        //    }
-
-        //    return value;
-        //}
-
         public static IList<T> HasNoNulls<T>(IList<T> value, [InvokerParameterName, ValidatedNotNull, NotNull] string parameterName)
             where T : class
         {
@@ -123,17 +109,5 @@ namespace WireMock.Validation
 
             return value;
         }
-
-        //public static Type ValidEntityType(Type value, [InvokerParameterName, ValidatedNotNull, NotNull] string parameterName)
-        //{
-        //    if (!value.GetTypeInfo().IsClass)
-        //    {
-        //        NotNullOrEmpty(parameterName, nameof(parameterName));
-
-        //        throw new ArgumentException(CoreStrings.InvalidEntityType(value, parameterName));
-        //    }
-
-        //    return value;
-        //}
     }
 }

src/WireMock.Net/WireMock.Net.csproj

@@ -3,7 +3,7 @@
     <Description>Lightweight Http Mocking Server for .Net, inspired by WireMock from the Java landscape.</Description>
     <AssemblyTitle>WireMock.Net</AssemblyTitle>
     <Authors>Stef Heyenrath</Authors>
-    <TargetFrameworks>net451;net452;net46;net461;netstandard1.3;netstandard2.0;netstandard2.1</TargetFrameworks>
+    <TargetFrameworks>net451;net452;net46;net461;netstandard1.3;netstandard2.0;netstandard2.1;netcoreapp3.1</TargetFrameworks>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <AssemblyName>WireMock.Net</AssemblyName>
     <PackageId>WireMock.Net</PackageId>
@@ -42,7 +42,7 @@
     <DefineConstants>NETSTANDARD;USE_ASPNETCORE</DefineConstants>
   </PropertyGroup>
 
-  <PropertyGroup Condition="'$(TargetFramework)' == 'netcoreapp2.1' or '$(TargetFramework)' == 'netcoreapp2.2'">
+  <PropertyGroup Condition="'$(TargetFramework)' == 'netcoreapp2.1' or '$(TargetFramework)' == 'netcoreapp2.2' or '$(TargetFramework)' == 'netcoreapp3.1'">
     <DefineConstants>USE_ASPNETCORE</DefineConstants>
   </PropertyGroup>
 
@@ -56,7 +56,7 @@
     <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
     <PackageReference Include="SimMetrics.Net" Version="1.0.5" />
     <PackageReference Include="System.Linq.Dynamic.Core" Version="1.0.12" />
-    <PackageReference Include="RandomDataGenerator.Net" Version="1.0.10" />
+    <PackageReference Include="RandomDataGenerator.Net" Version="1.0.12" />
     <PackageReference Include="JmesPath.Net" Version="1.0.125" />
     <PackageReference Include="Handlebars.Net.Helpers" Version="1.0.0" />
   </ItemGroup>
@@ -69,7 +69,7 @@
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' != 'netstandard1.3' ">
-    <PackageReference Include="XPath2.Extensions" Version="1.0.6.1" />
+    <PackageReference Include="XPath2.Extensions" Version="1.1.0" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'net451' ">
@@ -101,7 +101,11 @@
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'net461' ">
-    <PackageReference Include="Microsoft.AspNetCore" Version="2.1.2" />
+    <PackageReference Include="Microsoft.AspNetCore" Version="2.2.0" />
+
+    <!-- https://github.com/WireMock-Net/WireMock.Net/issues/507 -->
+    <PackageReference Include="Microsoft.AspNetCore.Server.IIS" Version="2.2.6" />
+
     <PackageReference Include="CS-Script" Version="3.29.0" />
   </ItemGroup>
 
@@ -114,17 +118,29 @@
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
-    <PackageReference Include="Microsoft.AspNetCore" Version="2.1.4" />
+    <PackageReference Include="Microsoft.AspNetCore" Version="2.2.0" />
+
+    <!-- https://github.com/WireMock-Net/WireMock.Net/issues/507 -->
+    <PackageReference Include="Microsoft.AspNetCore.Server.IIS" Version="2.2.6" />
     <PackageReference Include="CS-Script.Core" Version="1.1.1" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.1'">
-    <PackageReference Include="Microsoft.AspNetCore" Version="2.1.4" />
+    <PackageReference Include="Microsoft.AspNetCore" Version="2.2.0" />
+
+    <!-- https://github.com/WireMock-Net/WireMock.Net/issues/507 -->
+    <PackageReference Include="Microsoft.AspNetCore.Server.IIS" Version="2.2.6" />
 
     <!-- https://github.com/WireMock-Net/WireMock.Net/issues/448 -->
     <PackageReference Include="CS-Script.Core" Version="1.3.1" />
   </ItemGroup>
 
+  <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp3.1'">
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+    <!-- https://github.com/WireMock-Net/WireMock.Net/issues/448 -->
+    <PackageReference Include="CS-Script.Core" Version="1.4.0" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\WireMock.Net.Abstractions\WireMock.Net.Abstractions.csproj" />
   </ItemGroup>

test/WireMock.Net.Tests/FluentAssertions/WireMockAssertionsTests.cs

@@ -1,12 +1,15 @@
 using FluentAssertions;
 using System;
+using System.Linq;
 using System.Net.Http;
+using System.Net.Http.Headers;
 using WireMock.RequestBuilders;
 using WireMock.ResponseBuilders;
 using WireMock.Server;
 using Xunit;
 using WireMock.FluentAssertions;
 using System.Threading.Tasks;
+using static System.Environment;
 
 namespace WireMock.Net.Tests.FluentAssertions
 {
@@ -14,15 +17,26 @@ namespace WireMock.Net.Tests.FluentAssertions
     {
         private WireMockServer _server;
         private HttpClient _httpClient;
-        private const int Port = 42000;
+        private int _portUsed;
 
         public WireMockAssertionsTests()
         {
-            _server = WireMockServer.Start(Port);
+            _server = WireMockServer.Start();
             _server.Given(Request.Create().UsingAnyMethod())
-                            .RespondWith(Response.Create().WithStatusCode(200));
+                .RespondWith(Response.Create().WithStatusCode(200));
+            _portUsed = _server.Ports.First();
 
-            _httpClient = new HttpClient { BaseAddress = new Uri($"http://localhost:{Port}") };
+            _httpClient = new HttpClient { BaseAddress = new Uri($"http://localhost:{_portUsed}") };
+        }
+
+        [Fact]
+        public async Task AtAbsoluteUrl_WhenACallWasMadeToAbsoluteUrl_Should_BeOK()
+        {
+            await _httpClient.GetAsync("anyurl");
+
+            _server.Should()
+                .HaveReceivedACall()
+                .AtAbsoluteUrl($"http://localhost:{_portUsed}/anyurl");
         }
 
         [Fact]
@@ -50,7 +64,96 @@ namespace WireMock.Net.Tests.FluentAssertions
             act.Should().Throw<Exception>()
                 .And.Message.Should()
                 .Be(
-                    $"Expected _server to have been called at address matching the absolute url \"anyurl\", but didn't find it among the calls to {{\"http://localhost:{Port}/\"}}.");
+                    $"Expected _server to have been called at address matching the absolute url \"anyurl\", but didn't find it among the calls to {{\"http://localhost:{_portUsed}/\"}}.");
+        }
+
+        [Fact]
+        public async Task WithHeader_WhenACallWasMadeWithExpectedHeader_Should_BeOK()
+        {
+            _httpClient.DefaultRequestHeaders.Add("Authorization", "Bearer a");
+            await _httpClient.GetAsync("");
+
+            _server.Should()
+                .HaveReceivedACall()
+                .WithHeader("Authorization", "Bearer a");
+        }
+
+        [Fact]
+        public async Task WithHeader_WhenACallWasMadeWithExpectedHeaderAmongMultipleHeaderValues_Should_BeOK()
+        {
+            _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
+            _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
+            await _httpClient.GetAsync("");
+
+            _server.Should()
+                .HaveReceivedACall()
+                .WithHeader("Accept", new[] { "application/xml", "application/json" });
+        }
+
+        [Fact]
+        public async Task WithHeader_Should_ThrowWhenNoCallsMatchingTheHeaderNameWereMade()
+        {
+            await _httpClient.GetAsync("");
+
+            Action act = () => _server.Should()
+                .HaveReceivedACall()
+                .WithHeader("Authorization", "value");
+
+            var sentHeaders = _server.LogEntries.SelectMany(x => x.RequestMessage.Headers)
+                .ToDictionary(x => x.Key, x => x.Value)
+                .ToList();
+
+            var sentHeaderString = "{" + string.Join(", ", sentHeaders) + "}";
+
+            act.Should().Throw<Exception>()
+                .And.Message.Should()
+                .Be(
+                    $"Expected headers from requests sent {sentHeaderString} to contain key \"Authorization\".{NewLine}");
+        }
+
+        [Fact]
+        public async Task WithHeader_Should_ThrowWhenNoCallsMatchingTheHeaderValuesWereMade()
+        {
+            _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
+            _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
+            await _httpClient.GetAsync("");
+
+            Action act = () => _server.Should()
+                .HaveReceivedACall()
+                .WithHeader("Accept", "missing-value");
+
+            var sentHeaders = _server.LogEntries.SelectMany(x => x.RequestMessage.Headers)
+                .ToDictionary(x => x.Key, x => x.Value)["Accept"]
+                .Select(x => $"\"{x}\"")
+                .ToList();
+
+            var sentHeaderString = "{" + string.Join(", ", sentHeaders) + "}";
+
+            act.Should().Throw<Exception>()
+                .And.Message.Should()
+                .Be(
+                    $"Expected header \"Accept\" from requests sent with value(s) {sentHeaderString} to contain \"missing-value\".{NewLine}");
+        }
+
+        [Fact]
+        public async Task WithHeader_Should_ThrowWhenNoCallsMatchingTheHeaderWithMultipleValuesWereMade()
+        {
+            _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
+            _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
+            await _httpClient.GetAsync("");
+
+            Action act = () => _server.Should()
+                .HaveReceivedACall()
+                .WithHeader("Accept", new[] { "missing-value1", "missing-value2" });
+
+            const string missingValue1Message =
+                "Expected header \"Accept\" from requests sent with value(s) {\"application/xml\", \"application/json\"} to contain \"missing-value1\".";
+            const string missingValue2Message =
+                "Expected header \"Accept\" from requests sent with value(s) {\"application/xml\", \"application/json\"} to contain \"missing-value2\".";
+
+            act.Should().Throw<Exception>()
+                .And.Message.Should()
+                .Be($"{string.Join(NewLine, missingValue1Message, missingValue2Message)}{NewLine}");
         }
 
         public void Dispose()
@@ -59,4 +162,4 @@ namespace WireMock.Net.Tests.FluentAssertions
             _server?.Dispose();
         }
     }
-}
+}

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

@@ -1,92 +1,92 @@
-using NFluent;
+using NFluent;
-using WireMock.Matchers;
+using WireMock.Matchers;
-using Xunit;
+using Xunit;
-
+
-namespace WireMock.Net.Tests.Matchers
+namespace WireMock.Net.Tests.Matchers
-{
+{
-    public class CSharpCodeMatcherTests
+    public class CSharpCodeMatcherTests
-    {
+    {
-        [Fact]
+        [Fact]
-        public void CSharpCodeMatcher_For_String_SinglePattern_IsMatch_Positive()
+        public void CSharpCodeMatcher_For_String_SinglePattern_IsMatch_Positive()
-        {
+        {
-            // Assign
+            // Assign
-            string input = "x";
+            string input = "x";
-
+
-            // Act
+            // Act
-            var matcher = new CSharpCodeMatcher("return it == \"x\";");
+            var matcher = new CSharpCodeMatcher("return it == \"x\";");
-
+
-            // Assert
+            // Assert
-            Check.That(matcher.IsMatch(input)).IsEqualTo(1.0d);
+            Check.That(matcher.IsMatch(input)).IsEqualTo(1.0d);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void CSharpCodeMatcher_For_String_IsMatch_Negative()
+        public void CSharpCodeMatcher_For_String_IsMatch_Negative()
-        {
+        {
-            // Assign
+            // Assign
-            string input = "y";
+            string input = "y";
-
+
-            // Act
+            // Act
-            var matcher = new CSharpCodeMatcher("return it == \"x\";");
+            var matcher = new CSharpCodeMatcher("return it == \"x\";");
-
+
-            // Assert
+            // Assert
-            Check.That(matcher.IsMatch(input)).IsEqualTo(0.0d);
+            Check.That(matcher.IsMatch(input)).IsEqualTo(0.0d);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void CSharpCodeMatcher_For_String_IsMatch_RejectOnMatch()
+        public void CSharpCodeMatcher_For_String_IsMatch_RejectOnMatch()
-        {
+        {
-            // Assign
+            // Assign
-            string input = "x";
+            string input = "x";
-
+
-            // Act
+            // Act
-            var matcher = new CSharpCodeMatcher(MatchBehaviour.RejectOnMatch, "return it == \"x\";");
+            var matcher = new CSharpCodeMatcher(MatchBehaviour.RejectOnMatch, "return it == \"x\";");
-
+
-            // Assert
+            // Assert
-            Check.That(matcher.IsMatch(input)).IsEqualTo(0.0d);
+            Check.That(matcher.IsMatch(input)).IsEqualTo(0.0d);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void CSharpCodeMatcher_For_Object_IsMatch()
+        public void CSharpCodeMatcher_For_Object_IsMatch()
-        {
+        {
-            // Assign
+            // Assign
-            var input = new
+            var input = new
-            {
+            {
-                Id = 9,
+                Id = 9,
-                Name = "Test"
+                Name = "Test"
-            };
+            };
-
+
-            // Act
+            // Act
-            var matcher = new CSharpCodeMatcher("return it.Id > 1 && it.Name == \"Test\";");
+            var matcher = new CSharpCodeMatcher("return it.Id > 1 && it.Name == \"Test\";");
-            double match = matcher.IsMatch(input);
+            double match = matcher.IsMatch(input);
-
+
-            // Assert
+            // Assert
-            Assert.Equal(1.0, match);
+            Assert.Equal(1.0, match);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void CSharpCodeMatcher_GetName()
+        public void CSharpCodeMatcher_GetName()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new CSharpCodeMatcher("x");
+            var matcher = new CSharpCodeMatcher("x");
-
+
-            // Act
+            // Act
-            string name = matcher.Name;
+            string name = matcher.Name;
-
+
-            // Assert
+            // Assert
-            Check.That(name).Equals("CSharpCodeMatcher");
+            Check.That(name).Equals("CSharpCodeMatcher");
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void CSharpCodeMatcher_GetPatterns()
+        public void CSharpCodeMatcher_GetPatterns()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new CSharpCodeMatcher("x");
+            var matcher = new CSharpCodeMatcher("x");
-
+
-            // Act
+            // Act
-            string[] patterns = matcher.GetPatterns();
+            string[] patterns = matcher.GetPatterns();
-
+
-            // Assert
+            // Assert
-            Check.That(patterns).ContainsExactly("x");
+            Check.That(patterns).ContainsExactly("x");
-        }
+        }
-    }
+    }
 }

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

@@ -1,113 +1,113 @@
-using NFluent;
+using NFluent;
-using WireMock.Matchers;
+using WireMock.Matchers;
-using Xunit;
+using Xunit;
-
+
-namespace WireMock.Net.Tests.Matchers
+namespace WireMock.Net.Tests.Matchers
-{
+{
-    public class ExactMatcherTests
+    public class ExactMatcherTests
-    {
+    {
-        [Fact]
+        [Fact]
-        public void ExactMatcher_GetName()
+        public void ExactMatcher_GetName()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new ExactMatcher("X");
+            var matcher = new ExactMatcher("X");
-
+
-            // Act
+            // Act
-            string name = matcher.Name;
+            string name = matcher.Name;
-
+
-            // Assert
+            // Assert
-            Check.That(name).Equals("ExactMatcher");
+            Check.That(name).Equals("ExactMatcher");
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void ExactMatcher_GetPatterns()
+        public void ExactMatcher_GetPatterns()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new ExactMatcher("X");
+            var matcher = new ExactMatcher("X");
-
+
-            // Act
+            // Act
-            string[] patterns = matcher.GetPatterns();
+            string[] patterns = matcher.GetPatterns();
-
+
-            // Assert
+            // Assert
-            Check.That(patterns).ContainsExactly("X");
+            Check.That(patterns).ContainsExactly("X");
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void ExactMatcher_IsMatch_WithSinglePattern_ReturnsMatch1_0()
+        public void ExactMatcher_IsMatch_WithSinglePattern_ReturnsMatch1_0()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new ExactMatcher("x");
+            var matcher = new ExactMatcher("x");
-
+
-            // Act
+            // Act
-            double result = matcher.IsMatch("x");
+            double result = matcher.IsMatch("x");
-
+
-            // Assert
+            // Assert
-            Check.That(result).IsEqualTo(1.0);
+            Check.That(result).IsEqualTo(1.0);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void ExactMatcher_IsMatch_WithSinglePattern_ReturnsMatch0_0()
+        public void ExactMatcher_IsMatch_WithSinglePattern_ReturnsMatch0_0()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new ExactMatcher("x");
+            var matcher = new ExactMatcher("x");
-
+
-            // Act
+            // Act
-            double result = matcher.IsMatch("y");
+            double result = matcher.IsMatch("y");
-
+
-            // Assert
+            // Assert
-            Check.That(result).IsEqualTo(0.0);
+            Check.That(result).IsEqualTo(0.0);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void ExactMatcher_IsMatch_WithMultiplePatterns_ReturnsMatch0_5()
+        public void ExactMatcher_IsMatch_WithMultiplePatterns_ReturnsMatch0_5()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new ExactMatcher("x", "y");
+            var matcher = new ExactMatcher("x", "y");
-
+
-            // Act
+            // Act
-            double result = matcher.IsMatch("x");
+            double result = matcher.IsMatch("x");
-
+
-            // Assert
+            // Assert
-            Check.That(result).IsEqualTo(1.0);
+            Check.That(result).IsEqualTo(1.0);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void ExactMatcher_IsMatch_SinglePattern()
+        public void ExactMatcher_IsMatch_SinglePattern()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new ExactMatcher("cat");
+            var matcher = new ExactMatcher("cat");
-
+
-            // Act
+            // Act
-            double result = matcher.IsMatch("caR");
+            double result = matcher.IsMatch("caR");
-
+
-            // Assert
+            // Assert
-            Check.That(result).IsEqualTo(0.0);
+            Check.That(result).IsEqualTo(0.0);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void ExactMatcher_IsMatch_SinglePattern_AcceptOnMatch()
+        public void ExactMatcher_IsMatch_SinglePattern_AcceptOnMatch()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new ExactMatcher(MatchBehaviour.AcceptOnMatch, "cat");
+            var matcher = new ExactMatcher(MatchBehaviour.AcceptOnMatch, false, "cat");
-
+
-            // Act
+            // Act
-            double result = matcher.IsMatch("cat");
+            double result = matcher.IsMatch("cat");
-
+
-            // Assert
+            // Assert
-            Check.That(result).IsEqualTo(1.0);
+            Check.That(result).IsEqualTo(1.0);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void ExactMatcher_IsMatch_SinglePattern_RejectOnMatch()
+        public void ExactMatcher_IsMatch_SinglePattern_RejectOnMatch()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new ExactMatcher(MatchBehaviour.RejectOnMatch, "cat");
+            var matcher = new ExactMatcher(MatchBehaviour.RejectOnMatch, false, "cat");
-
+
-            // Act
+            // Act
-            double result = matcher.IsMatch("cat");
+            double result = matcher.IsMatch("cat");
-
+
-            // Assert
+            // Assert
-            Check.That(result).IsEqualTo(0.0);
+            Check.That(result).IsEqualTo(0.0);
-        }
+        }
-    }
+    }
 }

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

@@ -1,166 +1,166 @@
-using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Linq;
-using NFluent;
+using NFluent;
-using WireMock.Matchers;
+using WireMock.Matchers;
-using Xunit;
+using Xunit;
-
+
-namespace WireMock.Net.Tests.Matchers
+namespace WireMock.Net.Tests.Matchers
-{
+{
-    public class JmesPathMatcherTests
+    public class JmesPathMatcherTests
-    {
+    {
-        [Fact]
+        [Fact]
-        public void JmesPathMatcher_GetName()
+        public void JmesPathMatcher_GetName()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new JmesPathMatcher("X");
+            var matcher = new JmesPathMatcher("X");
-
+
-            // Act
+            // Act
-            string name = matcher.Name;
+            string name = matcher.Name;
-
+
-            // Assert
+            // Assert
-            Check.That(name).Equals("JmesPathMatcher");
+            Check.That(name).Equals("JmesPathMatcher");
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JmesPathMatcher_GetPatterns()
+        public void JmesPathMatcher_GetPatterns()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new JmesPathMatcher("X");
+            var matcher = new JmesPathMatcher("X");
-
+
-            // Act
+            // Act
-            string[] patterns = matcher.GetPatterns();
+            string[] patterns = matcher.GetPatterns();
-
+
-            // Assert
+            // Assert
-            Check.That(patterns).ContainsExactly("X");
+            Check.That(patterns).ContainsExactly("X");
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JmesPathMatcher_IsMatch_ByteArray()
+        public void JmesPathMatcher_IsMatch_ByteArray()
-        {
+        {
-            // Assign
+            // Assign
-            var bytes = new byte[0];
+            var bytes = new byte[0];
-            var matcher = new JmesPathMatcher("");
+            var matcher = new JmesPathMatcher("");
-
+
-            // Act 
+            // Act 
-            double match = matcher.IsMatch(bytes);
+            double match = matcher.IsMatch(bytes);
-
+
-            // Assert 
+            // Assert 
-            Check.That(match).IsEqualTo(0);
+            Check.That(match).IsEqualTo(0);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JmesPathMatcher_IsMatch_NullString()
+        public void JmesPathMatcher_IsMatch_NullString()
-        {
+        {
-            // Assign
+            // Assign
-            string s = null;
+            string s = null;
-            var matcher = new JmesPathMatcher("");
+            var matcher = new JmesPathMatcher("");
-
+
-            // Act 
+            // Act 
-            double match = matcher.IsMatch(s);
+            double match = matcher.IsMatch(s);
-
+
-            // Assert 
+            // Assert 
-            Check.That(match).IsEqualTo(0);
+            Check.That(match).IsEqualTo(0);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JmesPathMatcher_IsMatch_NullObject()
+        public void JmesPathMatcher_IsMatch_NullObject()
-        {
+        {
-            // Assign
+            // Assign
-            object o = null;
+            object o = null;
-            var matcher = new JmesPathMatcher("");
+            var matcher = new JmesPathMatcher("");
-
+
-            // Act 
+            // Act 
-            double match = matcher.IsMatch(o);
+            double match = matcher.IsMatch(o);
-
+
-            // Assert 
+            // Assert 
-            Check.That(match).IsEqualTo(0);
+            Check.That(match).IsEqualTo(0);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JmesPathMatcher_IsMatch_String_Exception_Mismatch()
+        public void JmesPathMatcher_IsMatch_String_Exception_Mismatch()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new JmesPathMatcher("xxx");
+            var matcher = new JmesPathMatcher("xxx");
-
+
-            // Act 
+            // Act 
-            double match = matcher.IsMatch("");
+            double match = matcher.IsMatch("");
-
+
-            // Assert 
+            // Assert 
-            Check.That(match).IsEqualTo(0);
+            Check.That(match).IsEqualTo(0);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JmesPathMatcher_IsMatch_Object_Exception_Mismatch()
+        public void JmesPathMatcher_IsMatch_Object_Exception_Mismatch()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new JmesPathMatcher("");
+            var matcher = new JmesPathMatcher("");
-
+
-            // Act 
+            // Act 
-            double match = matcher.IsMatch("x");
+            double match = matcher.IsMatch("x");
-
+
-            // Assert 
+            // Assert 
-            Check.That(match).IsEqualTo(0);
+            Check.That(match).IsEqualTo(0);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JmesPathMatcher_IsMatch_AnonymousObject()
+        public void JmesPathMatcher_IsMatch_AnonymousObject()
-        {
+        {
-            // Assign 
+            // Assign 
-            var matcher = new JmesPathMatcher("things.name == 'RequiredThing'");
+            var matcher = new JmesPathMatcher("things.name == 'RequiredThing'");
-
+
-            // Act
+            // Act
-            double match = matcher.IsMatch(new { things = new { name = "RequiredThing" } });
+            double match = matcher.IsMatch(new { things = new { name = "RequiredThing" } });
-
+
-            // Assert 
+            // Assert 
-            Check.That(match).IsEqualTo(1);
+            Check.That(match).IsEqualTo(1);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JmesPathMatcher_IsMatch_JObject()
+        public void JmesPathMatcher_IsMatch_JObject()
-        {
+        {
-            // Assign 
+            // Assign 
-            string[] patterns = { "things.x == 'RequiredThing'" };
+            string[] patterns = { "things.x == 'RequiredThing'" };
-            var matcher = new JmesPathMatcher(patterns);
+            var matcher = new JmesPathMatcher(patterns);
-
+
-            // Act
+            // Act
-            var sub = new JObject
+            var sub = new JObject
-            {
+            {
-                { "x", new JValue("RequiredThing") }
+                { "x", new JValue("RequiredThing") }
-            };
+            };
-            var jobject = new JObject
+            var jobject = new JObject
-            {
+            {
-                { "Id", new JValue(1) },
+                { "Id", new JValue(1) },
-                { "things", sub }
+                { "things", sub }
-            };
+            };
-            double match = matcher.IsMatch(jobject);
+            double match = matcher.IsMatch(jobject);
-
+
-            // Assert 
+            // Assert 
-            Check.That(match).IsEqualTo(1);
+            Check.That(match).IsEqualTo(1);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JmesPathMatcher_IsMatch_JObject_Parsed()
+        public void JmesPathMatcher_IsMatch_JObject_Parsed()
-        {
+        {
-            // Assign 
+            // Assign 
-            var matcher = new JmesPathMatcher("things.x == 'RequiredThing'");
+            var matcher = new JmesPathMatcher("things.x == 'RequiredThing'");
-
+
-            // Act 
+            // Act 
-            double match = matcher.IsMatch(JObject.Parse("{ \"things\": { \"x\": \"RequiredThing\" } }"));
+            double match = matcher.IsMatch(JObject.Parse("{ \"things\": { \"x\": \"RequiredThing\" } }"));
-
+
-            // Assert 
+            // Assert 
-            Check.That(match).IsEqualTo(1);
+            Check.That(match).IsEqualTo(1);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JmesPathMatcher_IsMatch_RejectOnMatch()
+        public void JmesPathMatcher_IsMatch_RejectOnMatch()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new JmesPathMatcher(MatchBehaviour.RejectOnMatch, "things.x == 'RequiredThing'");
+            var matcher = new JmesPathMatcher(MatchBehaviour.RejectOnMatch, false, "things.x == 'RequiredThing'");
-
+
-            // Act
+            // Act
-            double match = matcher.IsMatch(JObject.Parse("{ \"things\": { \"x\": \"RequiredThing\" } }"));
+            double match = matcher.IsMatch(JObject.Parse("{ \"things\": { \"x\": \"RequiredThing\" } }"));
-
+
-            // Assert
+            // Assert
-            Check.That(match).IsEqualTo(0.0);
+            Check.That(match).IsEqualTo(0.0);
-        }
+        }
-    }
+    }
 }

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

@@ -1,4 +1,8 @@
-using Newtonsoft.Json.Linq;
+using System;
+using System.IO;
+using FluentAssertions;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using NFluent;
 using WireMock.Matchers;
 using Xunit;
@@ -33,6 +37,52 @@ namespace WireMock.Net.Tests.Matchers
             Check.That(value).Equals("{}");
         }
 
+        [Fact]
+        public void JsonMatcher_WithInvalidStringValue_Should_ThrowException()
+        {
+            // Act
+            Action action = () => new JsonMatcher(MatchBehaviour.AcceptOnMatch, "{ \"Id\"");
+
+            // Assert
+            action.Should().Throw<JsonException>();
+        }
+
+        [Fact]
+        public void JsonMatcher_WithInvalidObjectValue_Should_ThrowException()
+        {
+            // Act
+            Action action = () => new JsonMatcher(MatchBehaviour.AcceptOnMatch, new MemoryStream());
+
+            // Assert
+            action.Should().Throw<JsonException>();
+        }
+
+        [Fact]
+        public void JsonMatcher_IsMatch_WithInvalidValue_And_ThrowExceptionIsFalse_Should_ReturnMismatch()
+        {
+            // Assign
+            var matcher = new JsonMatcher("");
+
+            // Act
+            double match = matcher.IsMatch(new MemoryStream());
+
+            // Assert 
+            Check.That(match).IsEqualTo(0);
+        }
+
+        [Fact]
+        public void JsonMatcher_IsMatch_WithInvalidValue_And_ThrowExceptionIsTrue_Should_ReturnMismatch()
+        {
+            // Assign
+            var matcher = new JsonMatcher("", false, true);
+
+            // Act
+            Action action = () => matcher.IsMatch(new MemoryStream());
+
+            // Assert 
+            action.Should().Throw<JsonException>();
+        }
+
         [Fact]
         public void JsonMatcher_IsMatch_ByteArray()
         {

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

@@ -1,162 +1,162 @@
-using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Linq;
-using NFluent;
+using NFluent;
-using WireMock.Matchers;
+using WireMock.Matchers;
-using Xunit;
+using Xunit;
-
+
-namespace WireMock.Net.Tests.Matchers
+namespace WireMock.Net.Tests.Matchers
-{
+{
-    public class JsonPathMatcherTests
+    public class JsonPathMatcherTests
-    {
+    {
-        [Fact]
+        [Fact]
-        public void JsonPathMatcher_GetName()
+        public void JsonPathMatcher_GetName()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new JsonPathMatcher("X");
+            var matcher = new JsonPathMatcher("X");
-
+
-            // Act
+            // Act
-            string name = matcher.Name;
+            string name = matcher.Name;
-
+
-            // Assert
+            // Assert
-            Check.That(name).Equals("JsonPathMatcher");
+            Check.That(name).Equals("JsonPathMatcher");
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JsonPathMatcher_GetPatterns()
+        public void JsonPathMatcher_GetPatterns()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new JsonPathMatcher("X");
+            var matcher = new JsonPathMatcher("X");
-
+
-            // Act
+            // Act
-            string[] patterns = matcher.GetPatterns();
+            string[] patterns = matcher.GetPatterns();
-
+
-            // Assert
+            // Assert
-            Check.That(patterns).ContainsExactly("X");
+            Check.That(patterns).ContainsExactly("X");
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JsonPathMatcher_IsMatch_ByteArray()
+        public void JsonPathMatcher_IsMatch_ByteArray()
-        {
+        {
-            // Assign
+            // Assign
-            var bytes = new byte[0];
+            var bytes = new byte[0];
-            var matcher = new JsonPathMatcher("");
+            var matcher = new JsonPathMatcher("");
-
+
-            // Act 
+            // Act 
-            double match = matcher.IsMatch(bytes);
+            double match = matcher.IsMatch(bytes);
-
+
-            // Assert 
+            // Assert 
-            Check.That(match).IsEqualTo(0);
+            Check.That(match).IsEqualTo(0);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JsonPathMatcher_IsMatch_NullString()
+        public void JsonPathMatcher_IsMatch_NullString()
-        {
+        {
-            // Assign
+            // Assign
-            string s = null;
+            string s = null;
-            var matcher = new JsonPathMatcher("");
+            var matcher = new JsonPathMatcher("");
-
+
-            // Act 
+            // Act 
-            double match = matcher.IsMatch(s);
+            double match = matcher.IsMatch(s);
-
+
-            // Assert 
+            // Assert 
-            Check.That(match).IsEqualTo(0);
+            Check.That(match).IsEqualTo(0);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JsonPathMatcher_IsMatch_NullObject()
+        public void JsonPathMatcher_IsMatch_NullObject()
-        {
+        {
-            // Assign
+            // Assign
-            object o = null;
+            object o = null;
-            var matcher = new JsonPathMatcher("");
+            var matcher = new JsonPathMatcher("");
-
+
-            // Act 
+            // Act 
-            double match = matcher.IsMatch(o);
+            double match = matcher.IsMatch(o);
-
+
-            // Assert 
+            // Assert 
-            Check.That(match).IsEqualTo(0);
+            Check.That(match).IsEqualTo(0);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JsonPathMatcher_IsMatch_String_Exception_Mismatch()
+        public void JsonPathMatcher_IsMatch_String_Exception_Mismatch()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new JsonPathMatcher("xxx");
+            var matcher = new JsonPathMatcher("xxx");
-
+
-            // Act 
+            // Act 
-            double match = matcher.IsMatch("");
+            double match = matcher.IsMatch("");
-
+
-            // Assert 
+            // Assert 
-            Check.That(match).IsEqualTo(0);
+            Check.That(match).IsEqualTo(0);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JsonPathMatcher_IsMatch_Object_Exception_Mismatch()
+        public void JsonPathMatcher_IsMatch_Object_Exception_Mismatch()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new JsonPathMatcher("");
+            var matcher = new JsonPathMatcher("");
-
+
-            // Act 
+            // Act 
-            double match = matcher.IsMatch("x");
+            double match = matcher.IsMatch("x");
-
+
-            // Assert 
+            // Assert 
-            Check.That(match).IsEqualTo(0);
+            Check.That(match).IsEqualTo(0);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JsonPathMatcher_IsMatch_AnonymousObject()
+        public void JsonPathMatcher_IsMatch_AnonymousObject()
-        {
+        {
-            // Assign 
+            // Assign 
-            var matcher = new JsonPathMatcher("$..[?(@.Id == 1)]");
+            var matcher = new JsonPathMatcher("$..[?(@.Id == 1)]");
-
+
-            // Act 
+            // Act 
-            double match = matcher.IsMatch(new { Id = 1, Name = "Test" });
+            double match = matcher.IsMatch(new { Id = 1, Name = "Test" });
-
+
-            // Assert 
+            // Assert 
-            Check.That(match).IsEqualTo(1);
+            Check.That(match).IsEqualTo(1);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JsonPathMatcher_IsMatch_JObject()
+        public void JsonPathMatcher_IsMatch_JObject()
-        {
+        {
-            // Assign 
+            // Assign 
-            string[] patterns = { "$..[?(@.Id == 1)]" };
+            string[] patterns = { "$..[?(@.Id == 1)]" };
-            var matcher = new JsonPathMatcher(patterns);
+            var matcher = new JsonPathMatcher(patterns);
-
+
-            // Act 
+            // Act 
-            var jobject = new JObject
+            var jobject = new JObject
-            {
+            {
-                { "Id", new JValue(1) },
+                { "Id", new JValue(1) },
-                { "Name", new JValue("Test") }
+                { "Name", new JValue("Test") }
-            };
+            };
-            double match = matcher.IsMatch(jobject);
+            double match = matcher.IsMatch(jobject);
-
+
-            // Assert 
+            // Assert 
-            Check.That(match).IsEqualTo(1);
+            Check.That(match).IsEqualTo(1);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JsonPathMatcher_IsMatch_JObject_Parsed()
+        public void JsonPathMatcher_IsMatch_JObject_Parsed()
-        {
+        {
-            // Assign 
+            // Assign 
-            var matcher = new JsonPathMatcher("$..[?(@.Id == 1)]");
+            var matcher = new JsonPathMatcher("$..[?(@.Id == 1)]");
-
+
-            // Act 
+            // Act 
-            double match = matcher.IsMatch(JObject.Parse("{\"Id\":1,\"Name\":\"Test\"}"));
+            double match = matcher.IsMatch(JObject.Parse("{\"Id\":1,\"Name\":\"Test\"}"));
-
+
-            // Assert 
+            // Assert 
-            Check.That(match).IsEqualTo(1);
+            Check.That(match).IsEqualTo(1);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void JsonPathMatcher_IsMatch_RejectOnMatch()
+        public void JsonPathMatcher_IsMatch_RejectOnMatch()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new JsonPathMatcher(MatchBehaviour.RejectOnMatch, "$..[?(@.Id == 1)]");
+            var matcher = new JsonPathMatcher(MatchBehaviour.RejectOnMatch, false, "$..[?(@.Id == 1)]");
-
+
-            // Act
+            // Act
-            double match = matcher.IsMatch(JObject.Parse("{\"Id\":1,\"Name\":\"Test\"}"));
+            double match = matcher.IsMatch(JObject.Parse("{\"Id\":1,\"Name\":\"Test\"}"));
-
+
-            // Assert
+            // Assert
-            Check.That(match).IsEqualTo(0.0);
+            Check.That(match).IsEqualTo(0.0);
-        }
+        }
-    }
+    }
 }

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

@@ -1,69 +1,69 @@
-using NFluent;
+using NFluent;
-using WireMock.Matchers;
+using WireMock.Matchers;
-using Xunit;
+using Xunit;
-
+
-namespace WireMock.Net.Tests.Matchers
+namespace WireMock.Net.Tests.Matchers
-{
+{
-    public class XPathMatcherTests
+    public class XPathMatcherTests
-    {
+    {
-        [Fact]
+        [Fact]
-        public void XPathMatcher_GetName()
+        public void XPathMatcher_GetName()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new XPathMatcher("X");
+            var matcher = new XPathMatcher("X");
-
+
-            // Act
+            // Act
-            string name = matcher.Name;
+            string name = matcher.Name;
-
+
-            // Assert
+            // Assert
-            Check.That(name).Equals("XPathMatcher");
+            Check.That(name).Equals("XPathMatcher");
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void XPathMatcher_GetPatterns()
+        public void XPathMatcher_GetPatterns()
-        {
+        {
-            // Assign
+            // Assign
-            var matcher = new XPathMatcher("X");
+            var matcher = new XPathMatcher("X");
-
+
-            // Act
+            // Act
-            string[] patterns = matcher.GetPatterns();
+            string[] patterns = matcher.GetPatterns();
-
+
-            // Assert
+            // Assert
-            Check.That(patterns).ContainsExactly("X");
+            Check.That(patterns).ContainsExactly("X");
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void XPathMatcher_IsMatch_AcceptOnMatch()
+        public void XPathMatcher_IsMatch_AcceptOnMatch()
-        {
+        {
-            // Assign
+            // Assign
-            string xml = @"
+            string xml = @"
-                    <todo-list>
+                    <todo-list>
-                        <todo-item id='a1'>abc</todo-item>
+                        <todo-item id='a1'>abc</todo-item>
-                    </todo-list>";
+                    </todo-list>";
-            var matcher = new XPathMatcher("/todo-list[count(todo-item) = 1]");
+            var matcher = new XPathMatcher("/todo-list[count(todo-item) = 1]");
-
+
-            // Act
+            // Act
-            double result = matcher.IsMatch(xml);
+            double result = matcher.IsMatch(xml);
-
+
-            // Assert
+            // Assert
-            Check.That(result).IsEqualTo(1.0);
+            Check.That(result).IsEqualTo(1.0);
-        }
+        }
-
+
-        [Fact]
+        [Fact]
-        public void XPathMatcher_IsMatch_RejectOnMatch()
+        public void XPathMatcher_IsMatch_RejectOnMatch()
-        {
+        {
-            // Assign
+            // Assign
-            string xml = @"
+            string xml = @"
-                    <todo-list>
+                    <todo-list>
-                        <todo-item id='a1'>abc</todo-item>
+                        <todo-item id='a1'>abc</todo-item>
-                    </todo-list>";
+                    </todo-list>";
-            var matcher = new XPathMatcher(MatchBehaviour.RejectOnMatch, "/todo-list[count(todo-item) = 1]");
+            var matcher = new XPathMatcher(MatchBehaviour.RejectOnMatch, false, "/todo-list[count(todo-item) = 1]");
-
+
-            // Act
+            // Act
-            double result = matcher.IsMatch(xml);
+            double result = matcher.IsMatch(xml);
-
+
-            // Assert
+            // Assert
-            Check.That(result).IsEqualTo(0.0);
+            Check.That(result).IsEqualTo(0.0);
-        }
+        }
-    }
+    }
 }

test/WireMock.Net.Tests/RequestBuilders/RequestBuilderWithParamTests.cs

@@ -34,10 +34,10 @@ namespace WireMock.Net.Tests.RequestBuilders
         }
 
         [Fact]
-        public void RequestBuilder_WithParam_String_IExactMatcher()
+        public void RequestBuilder_WithParam_String_IStringMatcher()
         {
             // Act
-            var requestBuilder = (Request)Request.Create().WithParam("p", new ExactMatcher("v"));
+            var requestBuilder = (Request)Request.Create().WithParam("p", new RegexMatcher("[012]"));
 
             // Assert
             var matchers = requestBuilder.GetPrivateFieldValue<IList<IRequestMatcher>>("_requestMatchers");

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

@@ -11,7 +11,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithStatusCodeTests
     {
-        private readonly Mock<IFluentMockServerSettings> _settingsMock = new Mock<IFluentMockServerSettings>();
+        private readonly Mock<IWireMockServerSettings> _settingsMock = new Mock<IWireMockServerSettings>();
         private const string ClientIp = "::1";
 
         [Theory]

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

@@ -25,7 +25,7 @@ namespace WireMock.Net.Tests.Serialization
             // Assign
             var request = Request.Create();
             var response = Response.Create();
-            var mapping = new Mapping(Guid.NewGuid(), "", null, _settings, request, response, 0, null, null, null);
+            var mapping = new Mapping(Guid.NewGuid(), "", null, _settings, request, response, 0, null, null, null, null);
 
             // Act
             var model = _sut.ToMappingModel(mapping);
@@ -44,7 +44,7 @@ namespace WireMock.Net.Tests.Serialization
             // Assign
             var request = Request.Create();
             var response = Response.Create().WithBodyAsJson(new { x = "x" }).WithTransformer();
-            var mapping = new Mapping(Guid.NewGuid(), "", null, _settings, request, response, 42, null, null, null);
+            var mapping = new Mapping(Guid.NewGuid(), "", null, _settings, request, response, 42, null, null, null, null);
 
             // Act
             var model = _sut.ToMappingModel(mapping);

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

@@ -1,4 +1,5 @@
 using System;
+using FluentAssertions;
 using NFluent;
 using WireMock.Admin.Mappings;
 using WireMock.Matchers;
@@ -43,7 +44,8 @@ namespace WireMock.Net.Tests.Serialization
             var matcher = (ExactMatcher)_sut.Map(model);
 
             // Assert
-            Check.That(matcher.GetPatterns()).ContainsExactly("x");
+            matcher.GetPatterns().Should().ContainSingle("x");
+            matcher.ThrowException.Should().BeFalse();
         }
 
         [Fact]
@@ -63,6 +65,39 @@ namespace WireMock.Net.Tests.Serialization
             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()
         {

test/WireMock.Net.Tests/StatefulBehaviorTests.cs

@@ -3,6 +3,7 @@ using System.Linq;
 using System.Net;
 using System.Net.Http;
 using System.Threading.Tasks;
+using FluentAssertions;
 using NFluent;
 using WireMock.RequestBuilders;
 using WireMock.ResponseBuilders;
@@ -61,6 +62,89 @@ namespace WireMock.Net.Tests
             Check.That(responseWithState).Equals("Test state msg");
         }
 
+        [Fact]
+        public async Task Scenarios_With_Same_Path_Should_Use_Times_When_Moving_To_Next_State()
+        {
+            // given
+            const int times = 2;
+            string path = $"/foo_{Guid.NewGuid()}";
+            string body1 = "Scenario S1, No State, Setting State T2";
+            string body2 = "Scenario S1, State T2, End";
+            var server = WireMockServer.Start();
+
+            server
+                .Given(Request.Create().WithPath(path).UsingGet())
+                .InScenario(1)
+                .WillSetStateTo(2, times)
+                .RespondWith(Response.Create().WithBody(body1));
+
+            server
+                .Given(Request.Create().WithPath(path).UsingGet())
+                .InScenario(1)
+                .WhenStateIs(2)
+                .RespondWith(Response.Create().WithBody(body2));
+
+            // when
+            var client = new HttpClient();
+            var responseScenario1 = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path);
+            var responseScenario2 = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path);
+            var responseWithState = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path);
+
+            // then
+            responseScenario1.Should().Be(body1);
+            responseScenario2.Should().Be(body1);
+            responseWithState.Should().Be(body2);
+        }
+
+        [Fact]
+        public async Task Scenarios_With_Different_Paths_Should_Use_Times_When_Moving_To_Next_State()
+        {
+            // given
+            const int times = 2;
+            string path1 = $"/a_{Guid.NewGuid()}";
+            string path2 = $"/b_{Guid.NewGuid()}";
+            string path3 = $"/c_{Guid.NewGuid()}";
+            string body1 = "Scenario S1, No State, Setting State T2";
+            string body2 = "Scenario S1, State T2, Setting State T3";
+            string body3 = "Scenario S1, State T3, End";
+
+            var server = WireMockServer.Start();
+
+            server
+                .Given(Request.Create().WithPath(path1).UsingGet())
+                .InScenario("S1")
+                .WillSetStateTo("T2", times)
+                .RespondWith(Response.Create().WithBody(body1));
+
+            server
+                .Given(Request.Create().WithPath(path2).UsingGet())
+                .InScenario("S1")
+                .WhenStateIs("T2")
+                .WillSetStateTo("T3", times)
+                .RespondWith(Response.Create().WithBody(body2));
+
+            server
+                .Given(Request.Create().WithPath(path3).UsingGet())
+                .InScenario("S1")
+                .WhenStateIs("T3")
+                .RespondWith(Response.Create().WithBody(body3));
+
+            // when
+            var client = new HttpClient();
+            var t1a = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path1);
+            var t1b = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path1);
+            var t2a = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path2);
+            var t2b = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path2);
+            var t3 = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path3);
+
+            // then
+            t1a.Should().Be(body1);
+            t1b.Should().Be(body1);
+            t2a.Should().Be(body2);
+            t2b.Should().Be(body2);
+            t3.Should().Be(body3);
+        }
+
         [Fact]
         public async Task Scenarios_Should_Respect_Int_Valued_Scenarios_and_States()
         {

test/WireMock.Net.Tests/WireMock.Net.Tests.csproj

@@ -44,17 +44,17 @@
     <PackageReference Include="FluentAssertions" Version="5.10.3" />
     <PackageReference Include="System.Threading" Version="4.3.0" />
     <PackageReference Include="RestEase" Version="1.4.10" />
-    <PackageReference Include="RandomDataGenerator.Net" Version="1.0.10" />
+    <PackageReference Include="RandomDataGenerator.Net" Version="1.0.12" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
-    <PackageReference Include="Moq" Version="4.13.1" />
+    <PackageReference Include="Moq" Version="4.14.5" />
     <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
     <PackageReference Include="NFluent" Version="2.7.0" />
     <PackageReference Include="OpenCover" Version="4.7.922" />
-    <PackageReference Include="ReportGenerator" Version="4.5.4" />
+    <PackageReference Include="ReportGenerator" Version="4.6.7" />
     <PackageReference Include="SimMetrics.Net" Version="1.0.5" />
     <PackageReference Include="System.Linq.Dynamic.Core" Version="1.0.12" />
     <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1">
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>