ExactMatcher : IgnoreCase (#817)

* ...

* mm

* fix some null warnings

* fx

src/WireMock.Net.Abstractions/Models/IBodyData.cs

@@ -13,12 +13,12 @@ public interface IBodyData
     /// <summary>
     /// The body (as bytearray).
     /// </summary>
-    byte[] BodyAsBytes { get; set; }
+    byte[]? BodyAsBytes { get; set; }
 
     /// <summary>
     /// Gets or sets the body as a file.
     /// </summary>
-    string BodyAsFile { get; set; }
+    string? BodyAsFile { get; set; }
 
     /// <summary>
     /// Is the body as file cached?
@@ -38,7 +38,7 @@ public interface IBodyData
     /// <summary>
     /// The body as string, this is defined when BodyAsString or BodyAsJson are not null.
     /// </summary>
-    string BodyAsString { get; set; }
+    string? BodyAsString { get; set; }
 
     /// <summary>
     /// The detected body type (detection based on body content).

src/WireMock.Net/Matchers/ExactMatcher.cs

@@ -1,7 +1,7 @@
+using System;
 using System.Linq;
 using AnyOfTypes;
 using Stef.Validation;
-using WireMock.Extensions;
 using WireMock.Models;
 
 namespace WireMock.Matchers;
@@ -9,8 +9,8 @@ namespace WireMock.Matchers;
 /// <summary>
 /// ExactMatcher
 /// </summary>
-/// <seealso cref="IStringMatcher" />
-public class ExactMatcher : IStringMatcher
+/// <seealso cref="IStringMatcher" /> and <seealso cref="IIgnoreCaseMatcher" />
+public class ExactMatcher : IStringMatcher, IIgnoreCaseMatcher
 {
     private readonly AnyOf<string, StringPattern>[] _values;
 
@@ -24,7 +24,16 @@ public class ExactMatcher : IStringMatcher
     /// Initializes a new instance of the <see cref="ExactMatcher"/> class.
     /// </summary>
     /// <param name="values">The values.</param>
-    public ExactMatcher(params AnyOf<string, StringPattern>[] values) : this(MatchBehaviour.AcceptOnMatch, false, MatchOperator.Or, values)
+    public ExactMatcher(params AnyOf<string, StringPattern>[] values) : this(MatchBehaviour.AcceptOnMatch, false, false, MatchOperator.Or, values)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ExactMatcher"/> class.
+    /// </summary>
+    /// <param name="ignoreCase">Ignore the case from the pattern(s).</param>
+    /// <param name="values">The values.</param>
+    public ExactMatcher(bool ignoreCase, params AnyOf<string, StringPattern>[] values) : this(MatchBehaviour.AcceptOnMatch, ignoreCase, false, MatchOperator.Or, values)
     {
     }
 
@@ -32,11 +41,13 @@ public class ExactMatcher : IStringMatcher
     /// Initializes a new instance of the <see cref="ExactMatcher"/> class.
     /// </summary>
     /// <param name="matchBehaviour">The match behaviour.</param>
+    /// <param name="ignoreCase">Ignore the case from the pattern(s).</param>
     /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
     /// <param name="matchOperator">The <see cref="Matchers.MatchOperator"/> to use. (default = "Or")</param>
     /// <param name="values">The values.</param>
     public ExactMatcher(
         MatchBehaviour matchBehaviour,
+        bool ignoreCase = false,
         bool throwException = false,
         MatchOperator matchOperator = MatchOperator.Or,
         params AnyOf<string, StringPattern>[] values)
@@ -45,13 +56,18 @@ public class ExactMatcher : IStringMatcher
 
         MatchBehaviour = matchBehaviour;
         ThrowException = throwException;
+        IgnoreCase = ignoreCase;
         MatchOperator = matchOperator;
     }
 
     /// <inheritdoc cref="IStringMatcher.IsMatch"/>
     public double IsMatch(string? input)
     {
-        double score = MatchScores.ToScore(_values.Select(v => v.GetPattern() == input).ToArray(), MatchOperator);
+        Func<string?, bool> equals = IgnoreCase
+            ? pattern => string.Equals(pattern, input, StringComparison.OrdinalIgnoreCase)
+            : pattern => pattern == input;
+
+        double score = MatchScores.ToScore(_values.Select(v => equals(v)).ToArray(), MatchOperator);
         return MatchBehaviourHelper.Convert(MatchBehaviour, score);
     }
 
@@ -66,4 +82,7 @@ public class ExactMatcher : IStringMatcher
 
     /// <inheritdoc cref="IMatcher.Name"/>
     public string Name => "ExactMatcher";
+
+    /// <inheritdoc />
+    public bool IgnoreCase { get; }
 }

src/WireMock.Net/Matchers/JsonPartialMatcher.cs

@@ -29,7 +29,7 @@ public class JsonPartialMatcher : AbstractJsonPartialMatcher
     /// <inheritdoc />
     protected override bool IsMatch(string value, string input)
     {
-        var exactStringMatcher = new ExactMatcher(MatchBehaviour.AcceptOnMatch, ThrowException, MatchOperator.Or, value);
+        var exactStringMatcher = new ExactMatcher(MatchBehaviour.AcceptOnMatch, IgnoreCase, ThrowException, MatchOperator.Or, value);
         return MatchScores.IsPerfect(exactStringMatcher.IsMatch(input));
     }
 }

src/WireMock.Net/Matchers/MatchOperator.cs

@@ -18,5 +18,5 @@ public enum MatchOperator
     /// <summary>
     /// The average value from all patterns.
     /// </summary>
-    Average,
+    Average
 }

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

@@ -16,22 +16,22 @@ public class RequestMessageBodyMatcher : IRequestMatcher
     /// <summary>
     /// The body function
     /// </summary>
-    public Func<string, bool>? Func { get; }
+    public Func<string?, bool>? Func { get; }
 
     /// <summary>
     /// The body data function for byte[]
     /// </summary>
-    public Func<byte[], bool>? DataFunc { get; }
+    public Func<byte[]?, bool>? DataFunc { get; }
 
     /// <summary>
     /// The body data function for json
     /// </summary>
-    public Func<object, bool>? JsonFunc { get; }
+    public Func<object?, bool>? JsonFunc { get; }
 
     /// <summary>
     /// The body data function for BodyData
     /// </summary>
-    public Func<IBodyData, bool>? BodyDataFunc { get; }
+    public Func<IBodyData?, bool>? BodyDataFunc { get; }
 
     /// <summary>
     /// The matchers.
@@ -77,7 +77,7 @@ public class RequestMessageBodyMatcher : IRequestMatcher
     /// Initializes a new instance of the <see cref="RequestMessageBodyMatcher"/> class.
     /// </summary>
     /// <param name="func">The function.</param>
-    public RequestMessageBodyMatcher(Func<string, bool> func)
+    public RequestMessageBodyMatcher(Func<string?, bool> func)
     {
         Func = Guard.NotNull(func);
     }
@@ -86,7 +86,7 @@ public class RequestMessageBodyMatcher : IRequestMatcher
     /// Initializes a new instance of the <see cref="RequestMessageBodyMatcher"/> class.
     /// </summary>
     /// <param name="func">The function.</param>
-    public RequestMessageBodyMatcher(Func<byte[], bool> func)
+    public RequestMessageBodyMatcher(Func<byte[]?, bool> func)
     {
         DataFunc = Guard.NotNull(func);
     }
@@ -95,7 +95,7 @@ public class RequestMessageBodyMatcher : IRequestMatcher
     /// Initializes a new instance of the <see cref="RequestMessageBodyMatcher"/> class.
     /// </summary>
     /// <param name="func">The function.</param>
-    public RequestMessageBodyMatcher(Func<object, bool> func)
+    public RequestMessageBodyMatcher(Func<object?, bool> func)
     {
         JsonFunc = Guard.NotNull(func);
     }
@@ -158,9 +158,9 @@ public class RequestMessageBodyMatcher : IRequestMatcher
         {
             // If the body is a byte array, try to match.
             var detectedBodyType = requestMessage.BodyData?.DetectedBodyType;
-            if (detectedBodyType == BodyType.Bytes || detectedBodyType == BodyType.String)
+            if (detectedBodyType is BodyType.Bytes or BodyType.String)
             {
-                return exactObjectMatcher.IsMatch(requestMessage.BodyData.BodyAsBytes);
+                return exactObjectMatcher.IsMatch(requestMessage.BodyData?.BodyAsBytes);
             }
         }
 

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

@@ -53,7 +53,7 @@ public class RequestMessageParamMatcher : IRequestMatcher
     /// <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, string key, bool ignoreCase, string[]? values) : this(matchBehaviour, key, ignoreCase, values?.Select(value => new ExactMatcher(matchBehaviour, false, MatchOperator.And, value)).Cast<IStringMatcher>().ToArray())
+    public RequestMessageParamMatcher(MatchBehaviour matchBehaviour, string key, bool ignoreCase, string[]? values) : this(matchBehaviour, key, ignoreCase, values?.Select(value => new ExactMatcher(matchBehaviour, ignoreCase, false, MatchOperator.And, value)).Cast<IStringMatcher>().ToArray())
     {
     }
 

src/WireMock.Net/Models/BodyData.cs

@@ -11,7 +11,7 @@ namespace WireMock.Util
         /// <inheritdoc cref="IBodyData.Encoding" />
         public Encoding? Encoding { get; set; }
 
-        /// <inheritdoc cref="IBodyData.BodyAsBytes" />
+        /// <inheritdoc />
         public string? BodyAsString { get; set; }
 
         /// <inheritdoc cref="IBodyData.BodyAsJson" />

src/WireMock.Net/Owin/AspNetCoreSelfHost.cs

@@ -107,7 +107,7 @@ namespace WireMock.Owin
         {
             try
             {
-                var appLifetime = (IApplicationLifetime)_host.Services.GetService(typeof(IApplicationLifetime));
+                var appLifetime = _host.Services.GetRequiredService<IApplicationLifetime>();
                 appLifetime.ApplicationStarted.Register(() =>
                 {
                     var addresses = _host.ServerFeatures

src/WireMock.Net/Proxy/ProxyHelper.cs

@@ -1,10 +1,17 @@
 using Stef.Validation;
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Net.Http;
 using System.Threading.Tasks;
+using WireMock.Constants;
 using WireMock.Http;
+using WireMock.Matchers;
+using WireMock.RequestBuilders;
+using WireMock.ResponseBuilders;
 using WireMock.Serialization;
 using WireMock.Settings;
+using WireMock.Types;
 using WireMock.Util;
 
 namespace WireMock.Proxy;
@@ -55,4 +62,69 @@ internal class ProxyHelper
 
         return (responseMessage, newMapping);
     }
+
+    private IMapping ToMapping(ProxyAndRecordSettings proxyAndRecordSettings, IRequestMessage requestMessage, ResponseMessage responseMessage)
+    {
+        var excludedHeaders = proxyAndRecordSettings.ExcludedHeaders ?? new string[] { };
+        var excludedCookies = proxyAndRecordSettings.ExcludedCookies ?? new string[] { };
+
+        var request = Request.Create();
+        request.WithPath(requestMessage.Path);
+        request.UsingMethod(requestMessage.Method);
+
+        requestMessage.Query?.Loop((key, value) => request.WithParam(key, false, value.ToArray()));
+        requestMessage.Cookies?.Loop((key, value) =>
+        {
+            if (!excludedCookies.Contains(key, StringComparer.OrdinalIgnoreCase))
+            {
+                request.WithCookie(key, value);
+            }
+        });
+
+        var allExcludedHeaders = new List<string>(excludedHeaders) { "Cookie" };
+        requestMessage.Headers?.Loop((key, value) =>
+        {
+            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!, true, throwExceptionWhenMatcherFails));
+                break;
+
+            case BodyType.String:
+                request.WithBody(new ExactMatcher(MatchBehaviour.AcceptOnMatch, false, throwExceptionWhenMatcherFails, MatchOperator.Or, requestMessage.BodyData.BodyAsString));
+                break;
+
+            case BodyType.Bytes:
+                request.WithBody(new ExactObjectMatcher(MatchBehaviour.AcceptOnMatch, requestMessage.BodyData.BodyAsBytes, throwExceptionWhenMatcherFails));
+                break;
+        }
+
+        var response = Response.Create(responseMessage);
+
+        return new Mapping
+        (
+            guid: Guid.NewGuid(),
+            title: $"Proxy Mapping for {requestMessage.Method} {requestMessage.Path}",
+            description: string.Empty,
+            path: null,
+            settings: _settings,
+            request,
+            response,
+            priority: WireMockConstants.ProxyPriority, // This was 0
+            scenario: null,
+            executionConditionState: null,
+            nextState: null,
+            stateTimes: null,
+            webhooks: null,
+            useWebhooksFireAndForget: null,
+            timeSettings: null
+        );
+    }
 }

src/WireMock.Net/Serialization/MatcherMapper.cs

@@ -66,7 +66,7 @@ internal class MatcherMapper
                 return new LinqMatcher(matchBehaviour, throwExceptionWhenMatcherFails, matchOperator, stringPatterns);
 
             case nameof(ExactMatcher):
-                return new ExactMatcher(matchBehaviour, throwExceptionWhenMatcherFails, matchOperator, stringPatterns);
+                return new ExactMatcher(matchBehaviour, ignoreCase, throwExceptionWhenMatcherFails, matchOperator, stringPatterns);
 
             case nameof(ExactObjectMatcher):
                 return CreateExactObjectMatcher(matchBehaviour, stringPatterns[0], throwExceptionWhenMatcherFails);

src/WireMock.Net/Serialization/ProxyMappingConverter.cs

@@ -140,11 +140,11 @@ internal class ProxyMappingConverter
                     break;
 
                 case BodyType.String:
-                    newRequest.WithBody(new ExactMatcher(MatchBehaviour.AcceptOnMatch, throwExceptionWhenMatcherFails, MatchOperator.Or, requestMessage.BodyData.BodyAsString));
+                    newRequest.WithBody(new ExactMatcher(MatchBehaviour.AcceptOnMatch, true, throwExceptionWhenMatcherFails, MatchOperator.Or, requestMessage.BodyData.BodyAsString!));
                     break;
 
                 case BodyType.Bytes:
-                    newRequest.WithBody(new ExactObjectMatcher(MatchBehaviour.AcceptOnMatch, requestMessage.BodyData.BodyAsBytes, throwExceptionWhenMatcherFails));
+                    newRequest.WithBody(new ExactObjectMatcher(MatchBehaviour.AcceptOnMatch, requestMessage.BodyData.BodyAsBytes!, throwExceptionWhenMatcherFails));
                     break;
             }
         }

src/WireMock.Net/Server/IRespondWithAProvider.cs

@@ -1,171 +1,169 @@
 using System;
 using System.Collections.Generic;
-using JetBrains.Annotations;
 using WireMock.Models;
 using WireMock.ResponseProviders;
 using WireMock.Types;
 
-namespace WireMock.Server
+namespace WireMock.Server;
+
+/// <summary>
+/// IRespondWithAProvider
+/// </summary>
+public interface IRespondWithAProvider
 {
     /// <summary>
-    /// IRespondWithAProvider
+    /// Gets the unique identifier for this mapping.
     /// </summary>
-    public interface IRespondWithAProvider
-    {
-        /// <summary>
-        /// Gets the unique identifier for this mapping.
-        /// </summary>
-        Guid Guid { get; }
+    Guid Guid { get; }
 
-        /// <summary>
-        /// Define a unique identifier for this mapping.
-        /// </summary>
-        /// <param name="guid">The unique identifier.</param>
-        /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
-        IRespondWithAProvider WithGuid(Guid guid);
+    /// <summary>
+    /// Define a unique identifier for this mapping.
+    /// </summary>
+    /// <param name="guid">The unique identifier.</param>
+    /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
+    IRespondWithAProvider WithGuid(Guid guid);
 
-        /// <summary>
-        /// Define the TimeSettings for this mapping.
-        /// </summary>
-        /// <param name="timeSettings">The TimeSettings.</param>
-        /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
-        IRespondWithAProvider WithTimeSettings(ITimeSettings timeSettings);
+    /// <summary>
+    /// Define the TimeSettings for this mapping.
+    /// </summary>
+    /// <param name="timeSettings">The TimeSettings.</param>
+    /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
+    IRespondWithAProvider WithTimeSettings(ITimeSettings timeSettings);
 
-        /// <summary>
-        /// Define a unique title for this mapping.
-        /// </summary>
-        /// <param name="title">The unique title.</param>
-        /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
-        IRespondWithAProvider WithTitle(string title);
+    /// <summary>
+    /// Define a unique title for this mapping.
+    /// </summary>
+    /// <param name="title">The unique title.</param>
+    /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
+    IRespondWithAProvider WithTitle(string title);
 
-        /// <summary>
-        /// Define a description for this mapping.
-        /// </summary>
-        /// <param name="description">The description.</param>
-        /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
-        IRespondWithAProvider WithDescription(string description);
+    /// <summary>
+    /// Define a description for this mapping.
+    /// </summary>
+    /// <param name="description">The description.</param>
+    /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
+    IRespondWithAProvider WithDescription(string description);
 
-        /// <summary>
-        /// Define the full filepath for this mapping.
-        /// </summary>
-        /// <param name="path">The full filepath.</param>
-        /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
-        IRespondWithAProvider WithPath(string path);
+    /// <summary>
+    /// Define the full filepath for this mapping.
+    /// </summary>
+    /// <param name="path">The full filepath.</param>
+    /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
+    IRespondWithAProvider WithPath(string path);
 
-        /// <summary>
-        /// Define a unique identifier for this mapping.
-        /// </summary>
-        /// <param name="guid">The unique identifier.</param>
-        /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
-        IRespondWithAProvider WithGuid(string guid);
+    /// <summary>
+    /// Define a unique identifier for this mapping.
+    /// </summary>
+    /// <param name="guid">The unique identifier.</param>
+    /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
+    IRespondWithAProvider WithGuid(string guid);
 
-        /// <summary>
-        /// Define the priority for this mapping.
-        /// </summary>
-        /// <param name="priority">The priority.</param>
-        /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
-        IRespondWithAProvider AtPriority(int priority);
+    /// <summary>
+    /// Define the priority for this mapping.
+    /// </summary>
+    /// <param name="priority">The priority.</param>
+    /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
+    IRespondWithAProvider AtPriority(int priority);
 
-        /// <summary>
-        /// The respond with.
-        /// </summary>
-        /// <param name="provider">The provider.</param>
-        void RespondWith(IResponseProvider provider);
+    /// <summary>
+    /// The respond with.
+    /// </summary>
+    /// <param name="provider">The provider.</param>
+    void RespondWith(IResponseProvider provider);
 
-        /// <summary>
-        /// Sets the the scenario.
-        /// </summary>
-        /// <param name="scenario">The scenario.</param>
-        /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
-        IRespondWithAProvider InScenario(string scenario);
+    /// <summary>
+    /// Sets the the scenario.
+    /// </summary>
+    /// <param name="scenario">The scenario.</param>
+    /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
+    IRespondWithAProvider InScenario(string scenario);
 
-        /// <summary>
-        /// Sets the the scenario with an integer value.
-        /// </summary>
-        /// <param name="scenario">The scenario.</param>
-        /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
-        IRespondWithAProvider InScenario(int scenario);
+    /// <summary>
+    /// Sets the the scenario with an integer value.
+    /// </summary>
+    /// <param name="scenario">The scenario.</param>
+    /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
+    IRespondWithAProvider InScenario(int scenario);
 
-        /// <summary>
-        /// Execute this respond only in case the current state is equal to specified one.
-        /// </summary>
-        /// <param name="state">Any object which identifies the current state</param>
-        /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
-        IRespondWithAProvider WhenStateIs(string state);
+    /// <summary>
+    /// Execute this respond only in case the current state is equal to specified one.
+    /// </summary>
+    /// <param name="state">Any object which identifies the current state</param>
+    /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
+    IRespondWithAProvider WhenStateIs(string state);
 
-        /// <summary>
-        /// Execute this respond only in case the current state is equal to specified one.
-        /// </summary>
-        /// <param name="state">Any object which identifies the current state</param>
-        /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
-        IRespondWithAProvider WhenStateIs(int state);
+    /// <summary>
+    /// Execute this respond only in case the current state is equal to specified one.
+    /// </summary>
+    /// <param name="state">Any object which identifies the current state</param>
+    /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
+    IRespondWithAProvider WhenStateIs(int state);
 
-        /// <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(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(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, 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, int? times = 1);
 
-        /// <summary>
-        /// Add (multiple) Webhook(s) to call after the response has been generated.
-        /// </summary>
-        /// <param name="webhooks">The Webhooks</param>
-        /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
-        IRespondWithAProvider WithWebhook(params IWebhook[] webhooks);
+    /// <summary>
+    /// Add (multiple) Webhook(s) to call after the response has been generated.
+    /// </summary>
+    /// <param name="webhooks">The Webhooks</param>
+    /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
+    IRespondWithAProvider WithWebhook(params IWebhook[] webhooks);
 
-        /// <summary>
-        /// Support FireAndForget for any configured Webhooks
-        /// </summary>
-        /// <param name="UseWebhooksFireAndForget"></param>
-        /// <returns></returns>
-        IRespondWithAProvider WithWebhookFireAndForget(bool UseWebhooksFireAndForget);
+    /// <summary>
+    /// Support FireAndForget for any configured Webhooks
+    /// </summary>
+    /// <param name="UseWebhooksFireAndForget"></param>
+    /// <returns></returns>
+    IRespondWithAProvider WithWebhookFireAndForget(bool UseWebhooksFireAndForget);
 
-        /// <summary>
-        /// Add a Webhook to call after the response has been generated.
-        /// </summary>
-        /// <param name="url">The Webhook Url</param>
-        /// <param name="method">The method to use. [optional]</param>
-        /// <param name="headers">The Headers to send. [optional]</param>
-        /// <param name="body">The body (as string) to send. [optional]</param>
-        /// <param name="useTransformer">Use Transformer. [optional]</param>
-        /// <param name="transformerType">The transformer type. [optional]</param>
-        /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
-        IRespondWithAProvider WithWebhook(
-            [NotNull] string url,
-            [CanBeNull] string method = "post",
-            [CanBeNull] IDictionary<string, WireMockList<string>> headers = null,
-            [CanBeNull] string body = null,
-            bool useTransformer = true,
-            TransformerType transformerType = TransformerType.Handlebars
-        );
+    /// <summary>
+    /// Add a Webhook to call after the response has been generated.
+    /// </summary>
+    /// <param name="url">The Webhook Url</param>
+    /// <param name="method">The method to use. [optional]</param>
+    /// <param name="headers">The Headers to send. [optional]</param>
+    /// <param name="body">The body (as string) to send. [optional]</param>
+    /// <param name="useTransformer">Use Transformer. [optional]</param>
+    /// <param name="transformerType">The transformer type. [optional]</param>
+    /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
+    IRespondWithAProvider WithWebhook(
+        string url,
+        string? method = "post",
+        IDictionary<string, WireMockList<string>>? headers = null,
+        string? body = null,
+        bool useTransformer = true,
+        TransformerType transformerType = TransformerType.Handlebars
+    );
 
-        /// <summary>
-        /// Add a Webhook to call after the response has been generated.
-        /// </summary>
-        /// <param name="url">The Webhook Url</param>
-        /// <param name="method">The method to use. [optional]</param>
-        /// <param name="headers">The Headers to send. [optional]</param>
-        /// <param name="body">The body (as json) to send. [optional]</param>
-        /// <param name="useTransformer">Use Transformer. [optional]</param>
-        /// <param name="transformerType">The transformer type. [optional]</param>
-        /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
-        IRespondWithAProvider WithWebhook(
-            [NotNull] string url,
-            [CanBeNull] string method = "post",
-            [CanBeNull] IDictionary<string, WireMockList<string>> headers = null,
-            [CanBeNull] object body = null,
-            bool useTransformer = true,
-            TransformerType transformerType = TransformerType.Handlebars
-        );
-    }
+    /// <summary>
+    /// Add a Webhook to call after the response has been generated.
+    /// </summary>
+    /// <param name="url">The Webhook Url</param>
+    /// <param name="method">The method to use. [optional]</param>
+    /// <param name="headers">The Headers to send. [optional]</param>
+    /// <param name="body">The body (as json) to send. [optional]</param>
+    /// <param name="useTransformer">Use Transformer. [optional]</param>
+    /// <param name="transformerType">The transformer type. [optional]</param>
+    /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
+    IRespondWithAProvider WithWebhook(
+        string url,
+        string? method = "post",
+        IDictionary<string, WireMockList<string>>? headers = null,
+        object? body = null,
+        bool useTransformer = true,
+        TransformerType transformerType = TransformerType.Handlebars
+    );
 }

src/WireMock.Net/Util/DictionaryExtensions.cs

@@ -17,6 +17,7 @@ public static class DictionaryExtensions
     /// <param name="dictionary">The dictionary to loop (can be null).</param>
     /// <param name="action">The action.</param>
     public static void Loop<TKey, TValue>(this IDictionary<TKey, TValue>? dictionary, Action<TKey, TValue> action)
+        where TKey : notnull
     {
         Guard.NotNull(action);
 

src/WireMock.Net/Util/TypeBuilderUtils.cs

@@ -32,7 +32,7 @@ internal static class TypeBuilderUtils
             CreateGetSetMethods(typeBuilder, property.Key, property.Value);
         }
 
-        var type = typeBuilder.CreateTypeInfo().AsType();
+        var type = typeBuilder.CreateTypeInfo()!.AsType();
 
         Types.TryAdd(properties, type);
 
@@ -43,6 +43,7 @@ internal static class TypeBuilderUtils
     /// https://stackoverflow.com/questions/3804367/testing-for-equality-between-dictionaries-in-c-sharp
     /// </summary>
     private static bool Compare<TKey, TValue>(IDictionary<TKey, TValue> dict1, IDictionary<TKey, TValue> dict2)
+        where TKey : notnull
     {
         if (dict1 == dict2)
         {

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

@@ -2,141 +2,153 @@ using NFluent;
 using WireMock.Matchers;
 using Xunit;
 
-namespace WireMock.Net.Tests.Matchers
+namespace WireMock.Net.Tests.Matchers;
+
+public class ExactMatcherTests
 {
-    public class ExactMatcherTests
+    [Fact]
+    public void ExactMatcher_GetName()
     {
-        [Fact]
-        public void ExactMatcher_GetName()
-        {
-            // Assign
-            var matcher = new ExactMatcher("X");
+        // Assign
+        var matcher = new ExactMatcher("X");
 
-            // Act
-            string name = matcher.Name;
+        // Act
+        string name = matcher.Name;
 
-            // Assert
-            Check.That(name).Equals("ExactMatcher");
-        }
+        // Assert
+        Check.That(name).Equals("ExactMatcher");
+    }
 
-        [Fact]
-        public void ExactMatcher_GetPatterns()
-        {
-            // Assign
-            var matcher = new ExactMatcher("X");
+    [Fact]
+    public void ExactMatcher_GetPatterns()
+    {
+        // Assign
+        var matcher = new ExactMatcher("X");
 
-            // Act
-            var patterns = matcher.GetPatterns();
+        // Act
+        var patterns = matcher.GetPatterns();
 
-            // Assert
-            Check.That(patterns).ContainsExactly("X");
-        }
+        // Assert
+        Check.That(patterns).ContainsExactly("X");
+    }
 
-        [Fact]
-        public void ExactMatcher_IsMatch_WithSinglePattern_ReturnsMatch1_0()
-        {
-            // Assign
-            var matcher = new ExactMatcher("x");
+    [Fact]
+    public void ExactMatcher_IsMatch_IgnoreCase()
+    {
+        // Assign
+        var matcher = new ExactMatcher(true, "x");
 
-            // Act
-            double result = matcher.IsMatch("x");
+        // Act
+        double result = matcher.IsMatch("X");
 
-            // Assert
-            Check.That(result).IsEqualTo(1.0);
-        }
+        // Assert
+        Check.That(result).IsEqualTo(1.0);
+    }
 
-        [Fact]
-        public void ExactMatcher_IsMatch_WithSinglePattern_ReturnsMatch0_0()
-        {
-            // Assign
-            var matcher = new ExactMatcher("x");
+    [Fact]
+    public void ExactMatcher_IsMatch_WithSinglePattern_ReturnsMatch1_0()
+    {
+        // Assign
+        var matcher = new ExactMatcher("x");
 
-            // Act
-            double result = matcher.IsMatch("y");
+        // Act
+        double result = matcher.IsMatch("x");
 
-            // Assert
-            Check.That(result).IsEqualTo(0.0);
-        }
+        // Assert
+        Check.That(result).IsEqualTo(1.0);
+    }
 
-        [Fact]
-        public void ExactMatcher_IsMatch_WithMultiplePatterns_Or_ReturnsMatch_1_0()
-        {
-            // Assign
-            var matcher = new ExactMatcher("x", "y");
+    [Fact]
+    public void ExactMatcher_IsMatch_WithSinglePattern_ReturnsMatch0_0()
+    {
+        // Assign
+        var matcher = new ExactMatcher("x");
 
-            // Act
-            double result = matcher.IsMatch("x");
+        // Act
+        double result = matcher.IsMatch("y");
 
-            // Assert
-            Check.That(result).IsEqualTo(1.0);
-        }
+        // Assert
+        Check.That(result).IsEqualTo(0.0);
+    }
 
-        [Fact]
-        public void ExactMatcher_IsMatch_WithMultiplePatterns_And_ReturnsMatch_0_0()
-        {
-            // Assign
-            var matcher = new ExactMatcher("x", "y");
+    [Fact]
+    public void ExactMatcher_IsMatch_WithMultiplePatterns_Or_ReturnsMatch_1_0()
+    {
+        // Assign
+        var matcher = new ExactMatcher("x", "y");
 
-            // Act
-            double result = matcher.IsMatch("x");
+        // Act
+        double result = matcher.IsMatch("x");
 
-            // Assert
-            Check.That(result).IsEqualTo(1.0);
-        }
+        // Assert
+        Check.That(result).IsEqualTo(1.0);
+    }
 
-        [Theory]
-        [InlineData(MatchOperator.Or, 1.0d)]
-        [InlineData(MatchOperator.And, 0.0d)]
-        [InlineData(MatchOperator.Average, 0.5d)]
-        public void ExactMatcher_IsMatch_WithMultiplePatterns_Average_ReturnsMatch(MatchOperator matchOperator, double score)
-        {
-            // Assign
-            var matcher = new ExactMatcher(MatchBehaviour.AcceptOnMatch, false, matchOperator, "x", "y");
+    [Fact]
+    public void ExactMatcher_IsMatch_WithMultiplePatterns_And_ReturnsMatch_0_0()
+    {
+        // Assign
+        var matcher = new ExactMatcher("x", "y");
 
-            // Act
-            double result = matcher.IsMatch("x");
+        // Act
+        double result = matcher.IsMatch("x");
 
-            // Assert
-            Check.That(result).IsEqualTo(score);
-        }
+        // Assert
+        Check.That(result).IsEqualTo(1.0);
+    }
 
-        [Fact]
-        public void ExactMatcher_IsMatch_SinglePattern()
-        {
-            // Assign
-            var matcher = new ExactMatcher("cat");
+    [Theory]
+    [InlineData(MatchOperator.Or, 1.0d)]
+    [InlineData(MatchOperator.And, 0.0d)]
+    [InlineData(MatchOperator.Average, 0.5d)]
+    public void ExactMatcher_IsMatch_WithMultiplePatterns_Average_ReturnsMatch(MatchOperator matchOperator, double score)
+    {
+        // Assign
+        var matcher = new ExactMatcher(MatchBehaviour.AcceptOnMatch, false, false, matchOperator, "x", "y");
 
-            // Act
-            double result = matcher.IsMatch("caR");
+        // Act
+        double result = matcher.IsMatch("x");
 
-            // Assert
-            Check.That(result).IsEqualTo(0.0);
-        }
+        // Assert
+        Check.That(result).IsEqualTo(score);
+    }
 
-        [Fact]
-        public void ExactMatcher_IsMatch_SinglePattern_AcceptOnMatch()
-        {
-            // Assign
-            var matcher = new ExactMatcher(MatchBehaviour.AcceptOnMatch, false, MatchOperator.Or, "cat");
+    [Fact]
+    public void ExactMatcher_IsMatch_SinglePattern()
+    {
+        // Assign
+        var matcher = new ExactMatcher("cat");
 
-            // Act
-            double result = matcher.IsMatch("cat");
+        // Act
+        double result = matcher.IsMatch("caR");
 
-            // Assert
-            Check.That(result).IsEqualTo(1.0);
-        }
+        // Assert
+        Check.That(result).IsEqualTo(0.0);
+    }
 
-        [Fact]
-        public void ExactMatcher_IsMatch_SinglePattern_RejectOnMatch()
-        {
-            // Assign
-            var matcher = new ExactMatcher(MatchBehaviour.RejectOnMatch, false, MatchOperator.Or, "cat");
+    [Fact]
+    public void ExactMatcher_IsMatch_SinglePattern_AcceptOnMatch()
+    {
+        // Assign
+        var matcher = new ExactMatcher(MatchBehaviour.AcceptOnMatch, false, false, MatchOperator.Or, "cat");
 
-            // Act
-            double result = matcher.IsMatch("cat");
+        // Act
+        double result = matcher.IsMatch("cat");
 
-            // Assert
-            Check.That(result).IsEqualTo(0.0);
-        }
+        // Assert
+        Check.That(result).IsEqualTo(1.0);
+    }
+
+    [Fact]
+    public void ExactMatcher_IsMatch_SinglePattern_RejectOnMatch()
+    {
+        // Assign
+        var matcher = new ExactMatcher(MatchBehaviour.RejectOnMatch, false, false, MatchOperator.Or, "cat");
+
+        // Act
+        double result = matcher.IsMatch("cat");
+
+        // Assert
+        Check.That(result).IsEqualTo(0.0);
     }
 }

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

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

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

@@ -80,7 +80,7 @@ public class ResponseWithTransformerTests
         var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
 
         // Assert
-        Check.That(response.Message.BodyData.BodyAsString).Equals("test http://localhost/foo /foo POSt");
+        Check.That(response.Message.BodyData!.BodyAsString).Equals("test http://localhost/foo /foo POSt");
     }
 
     [Theory]
@@ -104,7 +104,7 @@ public class ResponseWithTransformerTests
         var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
 
         // Assert
-        Check.That(response.Message.BodyData.BodyAsString).Equals("url=http://localhost/a/b absoluteurl=http://localhost/wiremock/a/b path=/a/b absolutepath=/wiremock/a/b");
+        Check.That(response.Message.BodyData!.BodyAsString).Equals("url=http://localhost/a/b absoluteurl=http://localhost/wiremock/a/b path=/a/b absolutepath=/wiremock/a/b");
     }
 
     [Fact]
@@ -122,7 +122,7 @@ public class ResponseWithTransformerTests
         var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
 
         // Assert
-        Check.That(response.Message.BodyData.BodyAsString).Equals("a wiremock");
+        Check.That(response.Message.BodyData!.BodyAsString).Equals("a wiremock");
     }
 
     [Theory(Skip = "Invalid token `OpenBracket`")]
@@ -142,7 +142,7 @@ public class ResponseWithTransformerTests
         var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
 
         // Assert
-        Check.That(response.Message.BodyData.BodyAsString).Equals("a wiremock");
+        Check.That(response.Message.BodyData!.BodyAsString).Equals("a wiremock");
     }
 
     [Fact]
@@ -164,7 +164,7 @@ public class ResponseWithTransformerTests
         var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
 
         // Assert
-        Check.That(response.Message.BodyData.BodyAsString).Equals("test keya=1,2 idx=1 idx=2 keyb=5");
+        Check.That(response.Message.BodyData!.BodyAsString).Equals("test keya=1,2 idx=1 idx=2 keyb=5");
     }
 
     [Theory(Skip = "Invalid token `OpenBracket`")]
@@ -188,7 +188,7 @@ public class ResponseWithTransformerTests
         var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
 
         // Assert
-        Check.That(response.Message.BodyData.BodyAsString).Equals("test keya=1 idx=1 idx=2 keyb=5");
+        Check.That(response.Message.BodyData!.BodyAsString).Equals("test keya=1 idx=1 idx=2 keyb=5");
     }
 
     [Fact]
@@ -211,7 +211,7 @@ public class ResponseWithTransformerTests
         var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
 
         // Assert
-        Check.That(response.Message.BodyData.BodyAsString).Equals("test");
+        Check.That(response.Message.BodyData!.BodyAsString).Equals("test");
         Check.That(response.Message.StatusCode).Equals("400");
     }
 
@@ -237,7 +237,7 @@ public class ResponseWithTransformerTests
         var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
 
         // Assert
-        Check.That(response.Message.BodyData.BodyAsString).Equals("test");
+        Check.That(response.Message.BodyData!.BodyAsString).Equals("test");
         Check.That(response.Message.StatusCode).Equals("400");
     }
 
@@ -263,7 +263,7 @@ public class ResponseWithTransformerTests
         var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
 
         // Assert
-        Check.That(response.Message.BodyData.BodyAsString).Equals("test");
+        Check.That(response.Message.BodyData!.BodyAsString).Equals("test");
         Check.That(response.Message.StatusCode).Equals(null);
     }
 
@@ -331,7 +331,7 @@ public class ResponseWithTransformerTests
         var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
 
         // Assert
-        Check.That(response.Message.BodyData.BodyAsString).Equals("test");
+        Check.That(response.Message.BodyData!.BodyAsString).Equals("test");
         Check.That(response.Message.Headers).ContainsKey("x");
         Check.That(response.Message.Headers["x"]).Contains("text/plain");
         Check.That(response.Message.Headers["x"]).Contains("http://localhost/foo");
@@ -356,7 +356,7 @@ public class ResponseWithTransformerTests
         var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
 
         // Assert
-        Check.That(response.Message.BodyData.BodyAsString).Equals("test");
+        Check.That(response.Message.BodyData!.BodyAsString).Equals("test");
         Check.That(response.Message.Headers).ContainsKey("x");
         Check.That(response.Message.Headers["x"]).Contains("text/plain");
         Check.That(response.Message.Headers["x"]).Contains("http://localhost/foo");
@@ -384,7 +384,7 @@ public class ResponseWithTransformerTests
         var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
 
         // Assert
-        Check.That(response.Message.BodyData.BodyAsString).Equals("test http://localhost:1234 1234 http localhost");
+        Check.That(response.Message.BodyData!.BodyAsString).Equals("test http://localhost:1234 1234 http localhost");
     }
 
     [Theory]
@@ -644,7 +644,7 @@ public class ResponseWithTransformerTests
         // Assert
         Check.That(response.Message.BodyData.BodyAsFile).Equals(@"c:\1\test.xml");
         Check.That(response.Message.BodyData.DetectedBodyType).Equals(BodyType.String);
-        Check.That(response.Message.BodyData.BodyAsString).Equals("<xml MyUniqueNumber=\"1\"></xml>");
+        Check.That(response.Message.BodyData!.BodyAsString).Equals("<xml MyUniqueNumber=\"1\"></xml>");
     }
 
     [Theory]

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

@@ -408,4 +408,24 @@ public class MatcherMapperTests
         matcher.Value.Should().BeEquivalentTo(pattern);
         matcher.Regex.Should().BeFalse();
     }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_ExactMatcher_Pattern()
+    {
+        // Assign
+        var model = new MatcherModel
+        {
+            Name = "ExactMatcher",
+            Pattern = "p",
+            IgnoreCase = true
+        };
+
+        // Act
+        var matcher = (ExactMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.GetPatterns().Should().Contain("p");
+        matcher.IgnoreCase.Should().BeTrue();
+    }
 }

test/WireMock.Net.Tests/Serialization/files/proxy.json

@@ -46,7 +46,8 @@
         "Matchers": [
           {
             "Name": "ExactMatcher",
-            "Pattern": "p1-v"
+            "Pattern": "p1-v",
+            "IgnoreCase": false
           }
         ]
       },
@@ -55,7 +56,8 @@
         "Matchers": [
           {
             "Name": "ExactMatcher",
-            "Pattern": "p2-v"
+            "Pattern": "p2-v",
+            "IgnoreCase": false
           }
         ]
       }

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

@@ -10,9 +10,6 @@
         <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
         <ProjectGuid>{31DC2EF8-C3FE-467D-84BE-FB5D956E612E}</ProjectGuid>
 
-        <!--<SonarQubeTestProject>True</SonarQubeTestProject>
-		<SonarQubeExclude>True</SonarQubeExclude>-->
-
         <SignAssembly>true</SignAssembly>
         <AssemblyOriginatorKeyFile>../../src/WireMock.Net/WireMock.Net.snk</AssemblyOriginatorKeyFile>
         <!--<DelaySign>true</DelaySign>-->
@@ -38,7 +35,6 @@
             <PrivateAssets>all</PrivateAssets>
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
-        <!--<PackageReference Include="Mapster" Version="7.2.0" />-->
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
         <PackageReference Include="xunit" Version="2.4.1" />
         <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
@@ -53,17 +49,11 @@
         <PackageReference Include="Moq" Version="4.17.2" />
         <PackageReference Include="System.Threading" Version="4.3.0" />
         <PackageReference Include="RestEase" Version="1.5.7" />
-        <!--<PackageReference Include="RandomDataGenerator.Net" Version="1.0.14" />-->
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
         <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
         <PackageReference Include="NFluent" Version="2.8.0" />
-        <!--<PackageReference Include="OpenCover" Version="4.7.922" />-->
-        <!--<PackageReference Include="ReportGenerator" Version="4.8.1" />-->
         <PackageReference Include="SimMetrics.Net" Version="1.0.5" />
         <PackageReference Include="System.Linq.Dynamic.Core" Version="1.2.19" />
-        <!--<PackageReference Include="StrongNamer" Version="0.2.5" />-->
         <PackageReference Include="AnyOf" Version="0.3.0" />
-        <!--<PackageReference Include="TinyMapper" Version="3.0.3" />-->
     </ItemGroup>
 
     <ItemGroup Condition="'$(TargetFramework)' == 'net452' or '$(TargetFramework)' == 'net461'">