1.5.52

* json matcher regex

* better test

* regression

CHANGELOG.md

@@ -1,3 +1,11 @@
+# 1.5.52 (06 April 2024)
+- [#1091](https://github.com/WireMock-Net/WireMock.Net/pull/1091) - Add RegEx support to JsonMatcher [feature] contributed by [StefH](https://github.com/StefH)
+- [#1088](https://github.com/WireMock-Net/WireMock.Net/issues/1088) - Regex support for JsonMatcher  [feature]
+
+# 1.5.51 (20 March 2024)
+- [#1085](https://github.com/WireMock-Net/WireMock.Net/pull/1085) - Fix FluentAssertions (actual body is not displayed in error message) [bug] contributed by [StefH](https://github.com/StefH)
+- [#1084](https://github.com/WireMock-Net/WireMock.Net/issues/1084) - FluentAssertions - Actual body is not displayed in error message when using Json Body [bug]
+
 # 1.5.50 (12 March 2024)
 - [#1080](https://github.com/WireMock-Net/WireMock.Net/pull/1080) - Fix FluentAssertions on Header(s) [bug] contributed by [StefH](https://github.com/StefH)
 - [#1082](https://github.com/WireMock-Net/WireMock.Net/pull/1082) - Make WireMockAssertions extendable [feature] contributed by [StefH](https://github.com/StefH)

Directory.Build.props

@@ -4,7 +4,7 @@
     </PropertyGroup>
 
     <PropertyGroup>
-        <VersionPrefix>1.5.50</VersionPrefix>
+        <VersionPrefix>1.5.52</VersionPrefix>
         <PackageIcon>WireMock.Net-Logo.png</PackageIcon>
         <PackageProjectUrl>https://github.com/WireMock-Net/WireMock.Net</PackageProjectUrl>
         <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>

Generate-ReleaseNotes.cmd

@@ -1,6 +1,6 @@
 rem https://github.com/StefH/GitHubReleaseNotes
 
-SET version=1.5.50
+SET version=1.5.52
 
 GitHubReleaseNotes --output CHANGELOG.md --skip-empty-releases --exclude-labels question invalid doc duplicate example --version %version% --token %GH_TOKEN%
 

PackageReleaseNotes.txt

@@ -1,7 +1,5 @@
-# 1.5.50 (12 March 2024)
-- #1080 Fix FluentAssertions on Header(s) [bug]
-- #1082 Make WireMockAssertions extendable [feature]
-- #1074 FluentAssertions extensions do not filter headers correctly [bug]
-- #1075 FluentAssertions extensions are not open for extension [feature]
+# 1.5.52 (06 April 2024)
+- #1091 Add RegEx support to JsonMatcher [feature]
+- #1088 Regex support for JsonMatcher  [feature]
 
 The full release notes can be found here: https://github.com/WireMock-Net/WireMock.Net/blob/master/CHANGELOG.md

examples/WireMock.Net.Console.NET7.UsingNuGet/Program.cs

@@ -1,6 +1,8 @@
 using System.Net;
+using System.Net.Http.Headers;
 using System.Text;
 using FluentAssertions;
+using MimeKit;
 using WireMock.Logging;
 using WireMock.RequestBuilders;
 using WireMock.ResponseBuilders;
@@ -18,17 +20,90 @@ internal class Program
             Logger = new WireMockConsoleLogger(),
         });
 
-        server.Given(Request.Create().UsingPost().WithPath("/some/endpoint"))
-            .RespondWith(Response.Create().WithStatusCode(HttpStatusCode.Created));
+        server
+            .Given(Request.Create()
+                .UsingPost()
+                .WithPath("/test")
+            )
+            .RespondWith(Response.Create()
+                .WithBody(requestMessage => requestMessage.BodyAsMimeMessage != null ?
+                    "BodyAsMimeMessage is present" :
+                    "BodyAsMimeMessage is not present")
+        );
 
-        var httpClient = new HttpClient { BaseAddress = new Uri(server.Url!) };
-        var requestUri = new Uri(httpClient.BaseAddress!, "some/endpoint");
-        var content = new StringContent(string.Empty, Encoding.UTF8, "application/json");
+        server
+            .Given(Request.Create()
+                .UsingPost()
+                .WithPath("/some/endpoint")
+            )
+            .RespondWith(Response.Create()
+                .WithStatusCode(HttpStatusCode.Created)
+            );
+
+        var httpClient = server.CreateClient();
+        var content = new StringContent("abc", Encoding.UTF8, "application/json");
+
+        await TestAsync(httpClient, content);
+
+        await TestNoMultiPartAsync(httpClient, content);
+
+        await TestMultiPartAsync(server);
+    }
+
+    private static async Task TestNoMultiPartAsync(HttpClient httpClient, StringContent content)
+    {
+        var response = await httpClient.PostAsync("/test", content);
+
+        response.StatusCode.Should().Be(HttpStatusCode.OK);
+        (await response.Content.ReadAsStringAsync()).Should().Be("BodyAsMimeMessage is not present");
+    }
+
+    private static async Task TestAsync(HttpClient httpClient, StringContent content)
+    {
+        var response = await httpClient.PostAsync("some/endpoint", content);
+
+        response.StatusCode.Should().Be(HttpStatusCode.Created);
+        (await response.Content.ReadAsStringAsync()).Should().BeEmpty();
+    }
+
+    private static async Task TestMultiPartAsync(WireMockServer server)
+    {
+        var textPlainContent = "This is some plain text";
+        var textPlainContentType = "text/plain";
+
+        var textJson = "{ \"Key\" : \"Value\" }";
+        var textJsonContentType = "text/json";
+
+        var imagePngBytes = Convert.FromBase64String("iVBORw0KGgoAAAANSUhEUgAAAAIAAAACAgMAAAAP2OW3AAAADFBMVEX/tID/vpH/pWX/sHidUyjlAAAADElEQVR4XmMQYNgAAADkAMHebX3mAAAAAElFTkSuQmCC");
+
+        server
+            .Given(
+                Request.Create()
+                    .UsingPost()
+                    .WithPath("/multipart")
+            )
+            .RespondWith(Response.Create()
+                .WithBody(requestMessage => requestMessage.BodyAsMimeMessage is MimeMessage mm ?
+                    "BodyAsMimeMessage is present: " + ((MimePart)mm.BodyParts.Last()).FileName :
+                    "BodyAsMimeMessage is not present")
+            );
 
         // Act
-        var actual = await httpClient.PostAsync(requestUri, content);
+        var formDataContent = new MultipartFormDataContent
+        {
+            { new StringContent(textPlainContent, Encoding.UTF8, textPlainContentType), "text" },
+            { new StringContent(textJson, Encoding.UTF8, textJsonContentType), "json" }
+        };
 
-        // Assert
-        actual.StatusCode.Should().Be(HttpStatusCode.Created);
+        var fileContent = new ByteArrayContent(imagePngBytes);
+        fileContent.Headers.ContentType = new MediaTypeHeaderValue("image/png");
+        formDataContent.Add(fileContent, "somefile", "image.png");
+
+        var client = server.CreateClient();
+
+        var response = await client.PostAsync("/multipart", formDataContent);
+
+        response.StatusCode.Should().Be(HttpStatusCode.OK);
+        (await response.Content.ReadAsStringAsync()).Should().Be("BodyAsMimeMessage is present: image.png");
     }
 }

examples/WireMock.Net.Console.NET7.UsingNuGet/WireMock.Net.Console.NET7.UsingNuGet.csproj

@@ -8,8 +8,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="FluentAssertions" Version="6.11.0" />
-    <PackageReference Include="WireMock.Net" Version="1.5.42" />
+    <PackageReference Include="FluentAssertions" Version="6.12.0" />
+    <PackageReference Include="WireMock.Net" Version="1.5.51" />
   </ItemGroup>
 
 </Project>

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

@@ -48,7 +48,7 @@ public class MatcherModel
     /// </summary>
     public string? MatchOperator { get; set; }
 
-    #region JsonPartialMatcher and JsonPartialWildcardMatcher
+    #region JsonMatcher, JsonPartialMatcher and JsonPartialWildcardMatcher
     /// <summary>
     /// Support Regex.
     /// </summary>

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

@@ -1,7 +1,12 @@
 #pragma warning disable CS1591
 using System;
 using System.Collections.Generic;
+using AnyOfTypes;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using WireMock.Extensions;
 using WireMock.Matchers;
+using WireMock.Models;
 
 // ReSharper disable once CheckNamespace
 namespace WireMock.FluentAssertions;
@@ -9,7 +14,7 @@ namespace WireMock.FluentAssertions;
 public partial class WireMockAssertions
 {
     private const string MessageFormatNoCalls = "Expected {context:wiremockserver} to have been called using body {0}{reason}, but no calls were made.";
-    private const string MessageFormat = "Expected {context:wiremockserver} to have been called using body {0}{reason}, but didn't find it among the body {1}.";
+    private const string MessageFormat = "Expected {context:wiremockserver} to have been called using body {0}{reason}, but didn't find it among the body/bodies {1}.";
 
     [CustomAssertion]
     public AndConstraint<WireMockAssertions> WithBody(string body, string because = "", params object[] becauseArgs)
@@ -56,7 +61,7 @@ public partial class WireMockAssertions
     {
         var (filter, condition) = BuildFilterAndCondition(r => r.BodyAsBytes, matcher);
 
-        return ExecuteAssertionWithBodyAsBytesExactObjectMatcher(matcher, because, becauseArgs, condition, filter, r => r.BodyAsBytes);
+        return ExecuteAssertionWithBodyAsIObjectMatcher(matcher, because, becauseArgs, condition, filter, r => r.BodyAsBytes);
     }
 
     private AndConstraint<WireMockAssertions> ExecuteAssertionWithBodyStringMatcher(
@@ -74,14 +79,14 @@ public partial class WireMockAssertions
             .ForCondition(requests => CallsCount == 0 || requests.Any())
             .FailWith(
                 MessageFormatNoCalls,
-                matcher.GetPatterns()
+                FormatBody(matcher.GetPatterns())
             )
             .Then
             .ForCondition(condition)
             .FailWith(
                 MessageFormat,
-                _ => matcher.GetPatterns(),
-                requests => requests.Select(expression)
+                _ => FormatBody(matcher.GetPatterns()),
+                requests => FormatBodies(requests.Select(expression))
             );
 
         FilterRequestMessages(filter);
@@ -104,14 +109,14 @@ public partial class WireMockAssertions
             .ForCondition(requests => CallsCount == 0 || requests.Any())
             .FailWith(
                 MessageFormatNoCalls,
-                matcher.Value
+                FormatBody(matcher.Value)
             )
             .Then
             .ForCondition(condition)
             .FailWith(
                 MessageFormat,
-                _ => matcher.Value,
-                requests => requests.Select(expression)
+                _ => FormatBody(matcher.Value),
+                requests => FormatBodies(requests.Select(expression))
             );
 
         FilterRequestMessages(filter);
@@ -119,33 +124,22 @@ public partial class WireMockAssertions
         return new AndConstraint<WireMockAssertions>(this);
     }
 
-    private AndConstraint<WireMockAssertions> ExecuteAssertionWithBodyAsBytesExactObjectMatcher(
-        ExactObjectMatcher matcher,
-        string because,
-        object[] becauseArgs,
-        Func<IReadOnlyList<IRequestMessage>, bool> condition,
-        Func<IReadOnlyList<IRequestMessage>, IReadOnlyList<IRequestMessage>> filter,
-        Func<IRequestMessage, object?> expression
-    )
+    private static string? FormatBody(object? body)
     {
-        Execute.Assertion
-            .BecauseOf(because, becauseArgs)
-            .Given(() => RequestMessages)
-            .ForCondition(requests => CallsCount == 0 || requests.Any())
-            .FailWith(
-                MessageFormatNoCalls,
-                matcher.Value
-            )
-            .Then
-            .ForCondition(condition)
-            .FailWith(
-                MessageFormat,
-                _ => matcher.Value,
-                requests => requests.Select(expression)
-            );
+        return body switch
+        {
+            null => null,
+            string str => str,
+            AnyOf<string, StringPattern>[] stringPatterns => FormatBodies(stringPatterns.Select(p => p.GetPattern())),
+            byte[] bytes => $"byte[{bytes.Length}] {{...}}",
+            JToken jToken => jToken.ToString(Formatting.None),
+            _ => JToken.FromObject(body).ToString(Formatting.None)
+        };
+    }
 
-        FilterRequestMessages(filter);
-
-        return new AndConstraint<WireMockAssertions>(this);
+    private static string? FormatBodies(IEnumerable<object?> bodies)
+    {
+        var valueAsArray = bodies as object[] ?? bodies.ToArray();
+        return valueAsArray.Length == 1 ? FormatBody(valueAsArray.First()) : $"[ {string.Join(", ", valueAsArray.Select(FormatBody))} ]";
     }
 }

src/WireMock.Net/Extensions/AnyOfExtensions.cs

@@ -5,18 +5,36 @@ using WireMock.Models;
 
 namespace WireMock.Extensions;
 
-internal static class AnyOfExtensions
+/// <summary>
+/// Some extensions for AnyOf.
+/// </summary>
+public static class AnyOfExtensions
 {
+    /// <summary>
+    /// Gets the pattern.
+    /// </summary>
+    /// <param name="value">AnyOf type</param>
+    /// <returns>string value</returns>
     public static string GetPattern(this AnyOf<string, StringPattern> value)
     {
         return value.IsFirst ? value.First : value.Second.Pattern;
     }
 
+    /// <summary>
+    /// Converts a string-patterns to AnyOf patterns.
+    /// </summary>
+    /// <param name="patterns">The string patterns</param>
+    /// <returns>The AnyOf patterns</returns>
     public static AnyOf<string, StringPattern>[] ToAnyOfPatterns(this IEnumerable<string> patterns)
     {
         return patterns.Select(p => p.ToAnyOfPattern()).ToArray();
     }
 
+    /// <summary>
+    /// Converts a string-pattern to AnyOf pattern.
+    /// </summary>
+    /// <param name="pattern">The string pattern</param>
+    /// <returns>The AnyOf pattern</returns>
     public static AnyOf<string, StringPattern> ToAnyOfPattern(this string pattern)
     {
         return new AnyOf<string, StringPattern>(pattern);

src/WireMock.Net/Matchers/AbstractJsonPartialMatcher.cs

@@ -10,20 +10,15 @@ namespace WireMock.Matchers;
 /// </summary>
 public abstract class AbstractJsonPartialMatcher : JsonMatcher
 {
-    /// <summary>
-    /// Support Regex
-    /// </summary>
-    public bool Regex { get; }
-
     /// <summary>
     /// Initializes a new instance of the <see cref="AbstractJsonPartialMatcher"/> class.
     /// </summary>
     /// <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>
     /// <param name="regex">Support Regex.</param>
-    protected AbstractJsonPartialMatcher(string value, bool ignoreCase = false, bool regex = false) : base(value, ignoreCase)
+    protected AbstractJsonPartialMatcher(string value, bool ignoreCase = false, bool regex = false) :
+        base(value, ignoreCase, regex)
     {
-        Regex = regex;
     }
 
     /// <summary>
@@ -32,9 +27,9 @@ public abstract class AbstractJsonPartialMatcher : JsonMatcher
     /// <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>
     /// <param name="regex">Support Regex.</param>
-    protected AbstractJsonPartialMatcher(object value, bool ignoreCase = false, bool regex = false) : base(value, ignoreCase)
+    protected AbstractJsonPartialMatcher(object value, bool ignoreCase = false, bool regex = false) :
+        base(value, ignoreCase, regex)
     {
-        Regex = regex;
     }
 
     /// <summary>
@@ -44,15 +39,15 @@ public abstract class AbstractJsonPartialMatcher : JsonMatcher
     /// <param name="value">The value to check for equality.</param>
     /// <param name="ignoreCase">Ignore the case from the PropertyName and PropertyValue (string only).</param>
     /// <param name="regex">Support Regex.</param>
-    protected AbstractJsonPartialMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false, bool regex = false) : base(matchBehaviour, value, ignoreCase)
+    protected AbstractJsonPartialMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false, bool regex = false) :
+        base(matchBehaviour, value, ignoreCase, regex)
     {
-        Regex = regex;
     }
 
     /// <inheritdoc />
-    protected override bool IsMatch(JToken? value, JToken? input)
+    protected override bool IsMatch(JToken value, JToken? input)
     {
-        if (value == null || value == input)
+        if (value == input)
         {
             return true;
         }
@@ -72,7 +67,7 @@ public abstract class AbstractJsonPartialMatcher : JsonMatcher
             ((value.Type == JTokenType.Guid && input.Type == JTokenType.String) ||
             (value.Type == JTokenType.String && input.Type == JTokenType.Guid)))
         {
-            return IsMatch(value.ToString(), input.ToString());
+            return IsMatch(value.ToString().ToUpperInvariant(), input.ToString().ToUpperInvariant());
         }
 
         if (input == null || value.Type != input.Type)

src/WireMock.Net/Matchers/JsonMatcher.cs

@@ -1,8 +1,10 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using Newtonsoft.Json.Linq;
 using Stef.Validation;
 using WireMock.Util;
+using JsonUtils = WireMock.Util.JsonUtils;
 
 namespace WireMock.Matchers;
 
@@ -23,6 +25,11 @@ public class JsonMatcher : IJsonMatcher
     /// <inheritdoc cref="IIgnoreCaseMatcher.IgnoreCase"/>
     public bool IgnoreCase { get; }
 
+    /// <summary>
+    /// Support Regex
+    /// </summary>
+    public bool Regex { get; }
+
     private readonly JToken _valueAsJToken;
     private readonly Func<JToken, JToken> _jTokenConverter;
 
@@ -31,7 +38,8 @@ public class JsonMatcher : IJsonMatcher
     /// </summary>
     /// <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(string value, bool ignoreCase = false) : this(MatchBehaviour.AcceptOnMatch, value, ignoreCase)
+    /// <param name="regex">Support Regex.</param>
+    public JsonMatcher(string value, bool ignoreCase = false, bool regex = false) : this(MatchBehaviour.AcceptOnMatch, value, ignoreCase, regex)
     {
     }
 
@@ -40,7 +48,8 @@ public class JsonMatcher : IJsonMatcher
     /// </summary>
     /// <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(object value, bool ignoreCase = false) : this(MatchBehaviour.AcceptOnMatch, value, ignoreCase)
+    /// <param name="regex">Support Regex.</param>
+    public JsonMatcher(object value, bool ignoreCase = false, bool regex = false) : this(MatchBehaviour.AcceptOnMatch, value, ignoreCase, regex)
     {
     }
 
@@ -50,12 +59,14 @@ public class JsonMatcher : IJsonMatcher
     /// <param name="matchBehaviour">The match behaviour.</param>
     /// <param name="value">The value to check for equality.</param>
     /// <param name="ignoreCase">Ignore the case from the PropertyName and PropertyValue (string only).</param>
-    public JsonMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false)
+    /// <param name="regex">Support Regex.</param>
+    public JsonMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false, bool regex = false)
     {
         Guard.NotNull(value);
 
         MatchBehaviour = matchBehaviour;
         IgnoreCase = ignoreCase;
+        Regex = regex;
 
         Value = value;
         _valueAsJToken = JsonUtils.ConvertValueToJToken(value);
@@ -93,9 +104,79 @@ public class JsonMatcher : IJsonMatcher
     /// <param name="value">Matcher value</param>
     /// <param name="input">Input value</param>
     /// <returns></returns>
-    protected virtual bool IsMatch(JToken value, JToken input)
+    protected virtual bool IsMatch(JToken value, JToken? input)
     {
-        return JToken.DeepEquals(value, input);
+        // If equal, return true.
+        if (input == value)
+        {
+            return true;
+        }
+
+        // If input is null, return false.
+        if (input == null)
+        {
+            return false;
+        }
+
+        // If using Regex and the value is a string, use the MatchRegex method.
+        if (Regex && value.Type == JTokenType.String)
+        {
+            var valueAsString = value.ToString();
+
+            var (valid, result) = RegexUtils.MatchRegex(valueAsString, input.ToString());
+            if (valid)
+            {
+                return result;
+            }
+        }
+
+        // If the value is a Guid and the input is a string, or vice versa, convert them to strings and compare the string values.
+        if ((value.Type == JTokenType.Guid && input.Type == JTokenType.String) || (value.Type == JTokenType.String && input.Type == JTokenType.Guid))
+        {
+            return JToken.DeepEquals(value.ToString().ToUpperInvariant(), input.ToString().ToUpperInvariant());
+        }
+
+        switch (value.Type)
+        {
+            // If the value is an object, compare all properties.
+            case JTokenType.Object:
+                var valueProperties = value.ToObject<Dictionary<string, JToken>>() ?? new Dictionary<string, JToken>();
+                var inputProperties = input.ToObject<Dictionary<string, JToken>>() ?? new Dictionary<string, JToken>();
+
+                // If the number of properties is different, return false.
+                if (valueProperties.Count != inputProperties.Count)
+                {
+                    return false;
+                }
+
+                // Compare all properties. The input must match all properties of the value.
+                foreach (var pair in valueProperties)
+                {
+                    if (!IsMatch(pair.Value, inputProperties[pair.Key]))
+                    {
+                        return false;
+                    }
+                }
+
+                return true;
+
+            // If the value is an array, compare all elements.
+            case JTokenType.Array:
+                var valueArray = value.ToObject<JToken[]>() ?? EmptyArray<JToken>.Value;
+                var inputArray = input.ToObject<JToken[]>() ?? EmptyArray<JToken>.Value;
+
+                // If the number of elements is different, return false.
+                if (valueArray.Length != inputArray.Length)
+                {
+                    return false;
+                }
+
+                return !valueArray.Where((valueToken, index) => !IsMatch(valueToken, inputArray[index])).Any();
+
+            default:
+                // Use JToken.DeepEquals() for all other types.
+                return JToken.DeepEquals(value, input);
+        }
     }
 
     private static string? ToUpper(string? input)

src/WireMock.Net/Serialization/MatcherMapper.cs

@@ -84,7 +84,7 @@ internal class MatcherMapper
 
             case nameof(JsonMatcher):
                 var valueForJsonMatcher = matcherModel.Pattern ?? matcherModel.Patterns;
-                return new JsonMatcher(matchBehaviour, valueForJsonMatcher!, ignoreCase);
+                return new JsonMatcher(matchBehaviour, valueForJsonMatcher!, ignoreCase, useRegex);
 
             case nameof(JsonPartialMatcher):
                 var valueForJsonPartialMatcher = matcherModel.Pattern ?? matcherModel.Patterns;
@@ -152,12 +152,8 @@ internal class MatcherMapper
 
         switch (matcher)
         {
-            case JsonPartialMatcher jsonPartialMatcher:
-                model.Regex = jsonPartialMatcher.Regex;
-                break;
-
-            case JsonPartialWildcardMatcher jsonPartialWildcardMatcher:
-                model.Regex = jsonPartialWildcardMatcher.Regex;
+            case JsonMatcher jsonMatcher:
+                model.Regex = jsonMatcher.Regex;
                 break;
 
             case XPathMatcher xpathMatcher:

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

@@ -702,7 +702,11 @@ public class WireMockAssertionsTests : IDisposable
         // Act
         var httpClient = new HttpClient();
 
-        await httpClient.PostAsync($"{server.Url}/a", new StringContent(@"{ ""x"": ""y"" }"));
+        var requestBody = new
+        {
+            x = "y"
+        };
+        await httpClient.PostAsJsonAsync($"{server.Url}/a", requestBody);
 
         // Assert
         server
@@ -740,6 +744,103 @@ public class WireMockAssertionsTests : IDisposable
         server.Stop();
     }
 
+    [Fact]
+    public async Task WithBodyAsJson_When_NoMatch_ShouldHaveCorrectErrorMessage()
+    {
+        // Arrange
+        var server = WireMockServer.Start();
+
+        server
+            .Given(Request.Create().WithPath("/a").UsingPost())
+            .RespondWith(Response.Create().WithBody("A response"));
+
+        // Act
+        var httpClient = new HttpClient();
+
+        var requestBody = new
+        {
+            x = "123"
+        };
+        await httpClient.PostAsJsonAsync($"{server.Url}/a", requestBody);
+
+        // Assert
+        Action act = () => server
+            .Should()
+            .HaveReceived(1)
+            .Calls()
+            .WithBodyAsJson(new { x = "y" })
+            .And
+            .UsingPost();
+
+        act.Should()
+            .Throw<Exception>()
+            .WithMessage("""Expected wiremockserver to have been called using body "{"x":"y"}", but didn't find it among the body/bodies "{"x":"123"}".""");
+
+        server.Stop();
+    }
+
+    [Fact]
+    public async Task WithBodyAsString_When_NoMatch_ShouldHaveCorrectErrorMessage()
+    {
+        // Arrange
+        var server = WireMockServer.Start();
+
+        server
+            .Given(Request.Create().WithPath("/a").UsingPost())
+            .RespondWith(Response.Create().WithBody("A response"));
+
+        // Act
+        var httpClient = new HttpClient();
+
+        await httpClient.PostAsync($"{server.Url}/a", new StringContent("123"));
+
+        // Assert
+        Action act = () => server
+            .Should()
+            .HaveReceived(1)
+            .Calls()
+            .WithBody("abc")
+            .And
+            .UsingPost();
+
+        act.Should()
+            .Throw<Exception>()
+            .WithMessage("""Expected wiremockserver to have been called using body "abc", but didn't find it among the body/bodies "123".""");
+
+        server.Stop();
+    }
+
+    [Fact]
+    public async Task WithBodyAsBytes_When_NoMatch_ShouldHaveCorrectErrorMessage()
+    {
+        // Arrange
+        var server = WireMockServer.Start();
+
+        server
+            .Given(Request.Create().WithPath("/a").UsingPost())
+            .RespondWith(Response.Create().WithBody("A response"));
+
+        // Act
+        var httpClient = new HttpClient();
+
+        await httpClient.PostAsync($"{server.Url}/a", new ByteArrayContent(new byte[] { 5 }));
+
+        // Assert
+        Action act = () => server
+            .Should()
+            .HaveReceived(1)
+            .Calls()
+            .WithBodyAsBytes(new byte[] { 1 })
+            .And
+            .UsingPost();
+
+        act.Should()
+            .Throw<Exception>()
+            .WithMessage("""Expected wiremockserver to have been called using body "byte[1] {...}", but didn't find it among the body/bodies "byte[1] {...}".""");
+
+        server.Stop();
+    }
+
     [Fact]
     public async Task HaveReceived1Call_WithBodyAsBytes()
     {

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

@@ -40,7 +40,7 @@ public class JsonMatcherTests
         var matcher = new JsonMatcher("{}");
 
         // Act
-        string name = matcher.Name;
+        var name = matcher.Name;
 
         // Assert
         Check.That(name).Equals("JsonMatcher");
@@ -53,7 +53,7 @@ public class JsonMatcherTests
         var matcher = new JsonMatcher("{}");
 
         // Act
-        object value = matcher.Value;
+        var value = matcher.Value;
 
         // Assert
         Check.That(value).Equals("{}");
@@ -90,7 +90,7 @@ public class JsonMatcherTests
         // Act
         var result = matcher.IsMatch(new MemoryStream());
 
-        // Assert 
+        // Assert
         result.Score.Should().Be(MatchScores.Mismatch);
         result.Exception.Should().BeAssignableTo<JsonException>();
     }
@@ -102,10 +102,10 @@ public class JsonMatcherTests
         var bytes = EmptyArray<byte>.Value;
         var matcher = new JsonMatcher("");
 
-        // Act 
-        double match = matcher.IsMatch(bytes).Score;
+        // Act
+        var match = matcher.IsMatch(bytes).Score;
 
-        // Assert 
+        // Assert
         Check.That(match).IsEqualTo(0);
     }
 
@@ -116,10 +116,10 @@ public class JsonMatcherTests
         string? s = null;
         var matcher = new JsonMatcher("");
 
-        // Act 
-        double match = matcher.IsMatch(s).Score;
+        // Act
+        var match = matcher.IsMatch(s).Score;
 
-        // Assert 
+        // Assert
         Check.That(match).IsEqualTo(0);
     }
 
@@ -130,215 +130,399 @@ public class JsonMatcherTests
         object? o = null;
         var matcher = new JsonMatcher("");
 
-        // Act 
-        double match = matcher.IsMatch(o).Score;
+        // Act
+        var match = matcher.IsMatch(o).Score;
 
-        // Assert 
+        // Assert
         Check.That(match).IsEqualTo(0);
     }
 
     [Fact]
     public void JsonMatcher_IsMatch_JArray()
     {
-        // Assign 
+        // Assign
         var matcher = new JsonMatcher(new[] { "x", "y" });
 
-        // Act 
+        // Act
         var jArray = new JArray
         {
             "x",
             "y"
         };
-        double match = matcher.IsMatch(jArray).Score;
+        var match = matcher.IsMatch(jArray).Score;
 
-        // Assert 
+        // Assert
         Assert.Equal(1.0, match);
     }
 
     [Fact]
-    public void JsonMatcher_IsMatch_JObject()
+    public void JsonMatcher_IsMatch_JObject_ShouldMatch()
     {
-        // Assign 
+        // Assign
         var matcher = new JsonMatcher(new { Id = 1, Name = "Test" });
 
-        // Act 
+        // Act
         var jObject = new JObject
         {
             { "Id", new JValue(1) },
             { "Name", new JValue("Test") }
         };
-        double match = matcher.IsMatch(jObject).Score;
+        var match = matcher.IsMatch(jObject).Score;
 
-        // Assert 
+        // Assert
         Assert.Equal(1.0, match);
     }
 
+    [Fact]
+    public void JsonMatcher_IsMatch_JObject_ShouldNotMatch()
+    {
+        // Assign
+        var matcher = new JsonMatcher(new { Id = 1, Name = "Test" });
+
+        // Act
+        var jObject = new JObject
+        {
+            { "Id", new JValue(1) },
+            { "Name", new JValue("Test") },
+            { "Other", new JValue("abc") }
+        };
+        var score = matcher.IsMatch(jObject).Score;
+
+        // Assert
+        Assert.Equal(MatchScores.Mismatch, score);
+    }
+
     [Fact]
     public void JsonMatcher_IsMatch_WithIgnoreCaseTrue_JObject()
     {
-        // Assign 
+        // Assign
         var matcher = new JsonMatcher(new { id = 1, Name = "test" }, true);
 
-        // Act 
+        // Act
         var jObject = new JObject
         {
             { "Id", new JValue(1) },
             { "NaMe", new JValue("Test") }
         };
-        double match = matcher.IsMatch(jObject).Score;
+        var match = matcher.IsMatch(jObject).Score;
 
-        // Assert 
+        // Assert
         Assert.Equal(1.0, match);
     }
 
     [Fact]
     public void JsonMatcher_IsMatch_JObjectParsed()
     {
-        // Assign 
+        // Assign
         var matcher = new JsonMatcher(new { Id = 1, Name = "Test" });
 
-        // Act 
+        // Act
         var jObject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
-        double match = matcher.IsMatch(jObject).Score;
+        var match = matcher.IsMatch(jObject).Score;
 
-        // Assert 
+        // Assert
         Assert.Equal(1.0, match);
     }
 
     [Fact]
     public void JsonMatcher_IsMatch_WithIgnoreCaseTrue_JObjectParsed()
     {
-        // Assign 
+        // Assign
         var matcher = new JsonMatcher(new { Id = 1, Name = "TESt" }, true);
 
-        // Act 
+        // Act
         var jObject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
-        double match = matcher.IsMatch(jObject).Score;
+        var match = matcher.IsMatch(jObject).Score;
 
-        // Assert 
+        // Assert
         Assert.Equal(1.0, match);
     }
 
     [Fact]
     public void JsonMatcher_IsMatch_JArrayAsString()
     {
-        // Assign 
+        // Assign
         var matcher = new JsonMatcher("[ \"x\", \"y\" ]");
 
-        // Act 
+        // Act
         var jArray = new JArray
         {
             "x",
             "y"
         };
-        double match = matcher.IsMatch(jArray).Score;
+        var match = matcher.IsMatch(jArray).Score;
 
-        // Assert 
+        // Assert
         Assert.Equal(1.0, match);
     }
 
     [Fact]
     public void JsonMatcher_IsMatch_JObjectAsString()
     {
-        // Assign 
+        // Assign
         var matcher = new JsonMatcher("{ \"Id\" : 1, \"Name\" : \"Test\" }");
 
-        // Act 
+        // Act
         var jObject = new JObject
         {
             { "Id", new JValue(1) },
             { "Name", new JValue("Test") }
         };
-        double match = matcher.IsMatch(jObject).Score;
+        var match = matcher.IsMatch(jObject).Score;
 
-        // Assert 
+        // Assert
         Assert.Equal(1.0, match);
     }
 
     [Fact]
     public void JsonMatcher_IsMatch_WithIgnoreCaseTrue_JObjectAsString()
     {
-        // Assign 
+        // Assign
         var matcher = new JsonMatcher("{ \"Id\" : 1, \"Name\" : \"test\" }", true);
 
-        // Act 
+        // Act
         var jObject = new JObject
         {
             { "Id", new JValue(1) },
             { "Name", new JValue("Test") }
         };
-        double match = matcher.IsMatch(jObject).Score;
+        var match = matcher.IsMatch(jObject).Score;
 
-        // Assert 
+        // Assert
         Assert.Equal(1.0, match);
     }
 
     [Fact]
     public void JsonMatcher_IsMatch_JObjectAsString_RejectOnMatch()
     {
-        // Assign 
+        // Assign
         var matcher = new JsonMatcher(MatchBehaviour.RejectOnMatch, "{ \"Id\" : 1, \"Name\" : \"Test\" }");
 
-        // Act 
+        // Act
         var jObject = new JObject
         {
             { "Id", new JValue(1) },
             { "Name", new JValue("Test") }
         };
-        double match = matcher.IsMatch(jObject).Score;
+        var match = matcher.IsMatch(jObject).Score;
 
-        // Assert 
+        // Assert
         Assert.Equal(0.0, match);
     }
 
     [Fact]
     public void JsonMatcher_IsMatch_JObjectWithDateTimeOffsetAsString()
     {
-        // Assign 
+        // Assign
         var matcher = new JsonMatcher("{ \"preferredAt\" : \"2019-11-21T10:32:53.2210009+00:00\" }");
 
-        // Act 
+        // Act
         var jObject = new JObject
         {
             { "preferredAt", new JValue("2019-11-21T10:32:53.2210009+00:00") }
         };
-        double match = matcher.IsMatch(jObject).Score;
+        var match = matcher.IsMatch(jObject).Score;
 
-        // Assert 
+        // Assert
         Assert.Equal(1.0, match);
     }
 
     [Fact]
     public void JsonMatcher_IsMatch_NormalEnum()
     {
-        // Assign 
-        var matcher = new JsonMatcher(new Test1 { NormalEnum = NormalEnum.Abc});
+        // Assign
+        var matcher = new JsonMatcher(new Test1 { NormalEnum = NormalEnum.Abc });
 
-        // Act 
+        // Act
         var jObject = new JObject
         {
             { "NormalEnum", new JValue(0) }
         };
-        double match = matcher.IsMatch(jObject).Score;
+        var match = matcher.IsMatch(jObject).Score;
 
-        // Assert 
+        // Assert
         match.Should().Be(1.0);
     }
 
     [Fact]
     public void JsonMatcher_IsMatch_EnumWithJsonConverter()
     {
-        // Assign 
+        // Assign
         var matcher = new JsonMatcher(new Test2 { EnumWithJsonConverter = EnumWithJsonConverter.Type1 });
 
-        // Act 
+        // Act
         var jObject = new JObject
         {
             { "EnumWithJsonConverter", new JValue("Type1") }
         };
-        double match = matcher.IsMatch(jObject).Score;
+        var match = matcher.IsMatch(jObject).Score;
 
-        // Assert 
+        // Assert
         match.Should().Be(1.0);
     }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_WithRegexTrue_ShouldMatch()
+    {
+        // Assign
+        var matcher = new JsonMatcher(new { Id = "^\\d+$", Name = "Test" }, regex: true);
+
+        // Act
+        var jObject = new JObject
+        {
+            { "Id", new JValue(42) },
+            { "Name", new JValue("Test") }
+        };
+        var score = matcher.IsMatch(jObject).Score;
+
+        // Assert
+        Assert.Equal(1.0, score);
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_WithRegexTrue_Complex_ShouldMatch()
+    {
+        // Assign
+        var matcher = new JsonMatcher(new
+        {
+            Complex = new
+            {
+                Id = "^\\d+$",
+                Name = ".*"
+            }
+        }, regex: true);
+
+        // Act
+        var jObject = new JObject
+        {
+            {
+                "Complex", new JObject
+                {
+                    { "Id", new JValue(42) },
+                    { "Name", new JValue("Test") }
+                }
+            }
+        };
+        var score = matcher.IsMatch(jObject).Score;
+
+        // Assert
+        Assert.Equal(1.0, score);
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_WithRegexTrue_Complex_ShouldNotMatch()
+    {
+        // Assign
+        var matcher = new JsonMatcher(new
+        {
+            Complex = new
+            {
+                Id = "^\\d+$",
+                Name = ".*"
+            }
+        }, regex: true);
+
+        // Act
+        var jObject = new JObject
+        {
+            {
+                "Complex", new JObject
+                {
+                    { "Id", new JValue(42) },
+                    { "Name", new JValue("Test") },
+                    { "Other", new JValue("Other") }
+                }
+            }
+        };
+        var score = matcher.IsMatch(jObject).Score;
+
+        // Assert
+        Assert.Equal(MatchScores.Mismatch, score);
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_WithRegexTrue_Array_ShouldMatch()
+    {
+        // Assign
+        var matcher = new JsonMatcher(new
+        {
+            Array = new[]
+            {
+                "^\\d+$",
+                ".*"
+            }
+        }, regex: true);
+
+        // Act
+        var jObject = new JObject
+        {
+            { "Array", new JArray("42", "test") }
+        };
+        var score = matcher.IsMatch(jObject).Score;
+
+        // Assert
+        Assert.Equal(1.0, score);
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_WithRegexTrue_Array_ShouldNotMatch()
+    {
+        // Assign
+        var matcher = new JsonMatcher(new
+        {
+            Array = new[]
+            {
+                "^\\d+$",
+                ".*"
+            }
+        }, regex: true);
+
+        // Act
+        var jObject = new JObject
+        {
+            { "Array", new JArray("42", "test", "other") }
+        };
+        var score = matcher.IsMatch(jObject).Score;
+
+        // Assert
+        Assert.Equal(MatchScores.Mismatch, score);
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_GuidAndString()
+    {
+        // Assign
+        var id = Guid.NewGuid();
+        var idAsString = id.ToString();
+        var matcher = new JsonMatcher(new { Id = id });
+
+        // Act
+        var jObject = new JObject
+        {
+            { "Id", new JValue(idAsString) }
+        };
+        var score = matcher.IsMatch(jObject).Score;
+
+        // Assert
+        Assert.Equal(1.0, score);
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_StringAndGuid()
+    {
+        // Assign
+        var id = Guid.NewGuid();
+        var idAsString = id.ToString();
+        var matcher = new JsonMatcher(new { Id = idAsString });
+
+        // Act
+        var jObject = new JObject
+        {
+            { "Id", new JValue(id) }
+        };
+        var score = matcher.IsMatch(jObject).Score;
+
+        // Assert
+        Assert.Equal(1.0, score);
+    }
 }

test/WireMock.Net.Tests/Serialization/MappingConverterTests.ToMappingModel_Mapping_WithBodyAsProtoBuf_ReturnsCorrectModel.verified.txt

@@ -25,7 +25,8 @@
           Pattern: {
             name: stef
           },
-          IgnoreCase: false
+          IgnoreCase: false,
+          Regex: false
         },
         ProtoBufMessageType: greet.HelloRequest
       }

test/WireMock.Net.Tests/Serialization/MappingConverterTests.ToMappingModel_Request_WithBodyAsProtoBuf_ReturnsCorrectModel.verified.txt

@@ -42,7 +42,8 @@ message HelloReply {
           Pattern: {
             name: stef
           },
-          IgnoreCase: false
+          IgnoreCase: false,
+          Regex: false
         },
         ProtoBufMessageType: greet.HelloRequest
       }