mm

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

@@ -1,9 +1,8 @@
 // Copyright © WireMock.Net
 
-using System;
 using System.Text;
-using System.Threading.Tasks;
 using FluentAssertions;
+using JsonConverter.Newtonsoft.Json;
 using Microsoft.AspNetCore.Http;
 using Moq;
 using Newtonsoft.Json.Linq;
@@ -14,7 +13,6 @@ using WireMock.ResponseBuilders;
 using WireMock.Settings;
 using WireMock.Types;
 using WireMock.Util;
-using Xunit;
 
 namespace WireMock.Net.Tests.ResponseBuilders;
 
@@ -317,12 +315,11 @@ public class ResponseWithBodyTests
         var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request1, _settings);
 
         Check.That(response.Message.StatusCode).IsEqualTo(200);
-        Check.That(response.Message.BodyData.BodyAsString).Contains("File deleted.");
+        Check.That(response.Message.BodyData?.BodyAsString).Contains("File deleted.");
     }
 
-#if !(NET451 || NET452)
     [Fact]
-    public async Task Response_ProvideResponse_WithBody_IJsonConverter_SystemTextJson()
+    public async Task Response_ProvideResponse_WithBody_NewtonsoftJsonConverter()
     {
         // Arrange
         var requestBody = new BodyData
@@ -332,13 +329,34 @@ public class ResponseWithBodyTests
         };
         var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, requestBody);
 
-        var responseBuilder = Response.Create().WithBody(new { foo = "bar", n = 42 }, new JsonConverter.System.Text.Json.SystemTextJsonConverter());
+        var responseBuilder = Response.Create().WithBody(new { foo = "< > & ' 😀 👍 ❤️", n = 42 }, new NewtonsoftJsonConverter());
+
+        // Act
+        var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings).ConfigureAwait(false);
+
+        // Assert
+        response.Message.BodyData!.BodyAsString.Should().Be("""{"foo":"< > & ' 😀 👍 ❤️","n":42}""");
+    }
+
+#if !(NET451 || NET452 || NET461)
+    [Fact]
+    public async Task Response_ProvideResponse_WithBody_SystemTextJsonConverter()
+    {
+        // Arrange
+        var requestBody = new BodyData
+        {
+            DetectedBodyType = BodyType.String,
+            BodyAsString = "abc"
+        };
+        var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, requestBody);
+
+        var responseBuilder = Response.Create().WithBody(new { foo = "< > & ' 😀 👍 ❤️", n = 42 }, new JsonConverter.System.Text.Json.SystemTextJsonConverter());
 
         // Act
         var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
 
         // Assert
-        response.Message.BodyData!.BodyAsString.Should().Be(@"{""foo"":""bar"",""n"":42}");
+        response.Message.BodyData!.BodyAsString.Should().Be("""{"foo":"\u003C \u003E \u0026 \u0027 \uD83D\uDE00 \uD83D\uDC4D \u2764\uFE0F","n":42}""");
     }
 #endif
 }

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

@@ -0,0 +1,326 @@
+// Copyright © WireMock.Net
+
+using System;
+using FluentAssertions;
+using JsonConverter.Newtonsoft.Json;
+using WireMock.Admin.Mappings;
+using WireMock.Serialization;
+using Xunit;
+#if NET8_0_OR_GREATER
+using JsonConverter.System.Text.Json;
+#endif
+
+namespace WireMock.Net.Tests.Serialization;
+
+public class MappingSerializerTests
+{
+    private const string SingleMappingJson =
+        """
+        {
+            "Guid": "12345678-1234-1234-1234-123456789012",
+            "Priority": 1,
+            "Request": {
+                "Path": "/test"
+            },
+            "Response": {
+                "StatusCode": 200
+            }
+        }
+        """;
+
+    private const string ArrayMappingJson =
+        """
+        [
+            {
+                "Guid": "12345678-1234-1234-1234-123456789012",
+                "Priority": 1,
+                "Request": {
+                    "Path": "/test1"
+                },
+                "Response": {
+                    "StatusCode": 200
+                }
+            },
+            {
+                "Guid": "87654321-4321-4321-4321-210987654321",
+                "Priority": 2,
+                "Request": {
+                    "Path": "/test2"
+                },
+                "Response": {
+                    "StatusCode": 404
+                }
+            }
+        ]
+        """;
+
+    [Fact]
+    public void MappingSerializer_DeserializeJsonToArray_WithNewtonsoftJson_SingleObject_ShouldReturnArray()
+    {
+        // Arrange
+        var jsonConverter = new NewtonsoftJsonConverter();
+        var serializer = new MappingSerializer(jsonConverter);
+
+        // Act
+        var result = serializer.DeserializeJsonToArray<MappingModel>(SingleMappingJson);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Should().HaveCount(1);
+        result[0].Guid.Should().Be(Guid.Parse("12345678-1234-1234-1234-123456789012"));
+        result[0].Priority.Should().Be(1);
+    }
+
+    [Fact]
+    public void MappingSerializer_DeserializeJsonToArray_WithNewtonsoftJson_Array_ShouldReturnArray()
+    {
+        // Arrange
+        var jsonConverter = new NewtonsoftJsonConverter();
+        var serializer = new MappingSerializer(jsonConverter);
+
+        // Act
+        var result = serializer.DeserializeJsonToArray<MappingModel>(ArrayMappingJson);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Should().HaveCount(2);
+        result[0].Guid.Should().Be(Guid.Parse("12345678-1234-1234-1234-123456789012"));
+        result[0].Priority.Should().Be(1);
+        result[1].Guid.Should().Be(Guid.Parse("87654321-4321-4321-4321-210987654321"));
+        result[1].Priority.Should().Be(2);
+    }
+
+    [Fact]
+    public void MappingSerializer_DeserializeJsonToArray_WithNewtonsoftJson_EmptyArray_ShouldReturnEmptyArray()
+    {
+        // Arrange
+        var jsonConverter = new NewtonsoftJsonConverter();
+        var serializer = new MappingSerializer(jsonConverter);
+        var emptyArrayJson = "[]";
+
+        // Act
+        var result = serializer.DeserializeJsonToArray<MappingModel>(emptyArrayJson);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void MappingSerializer_DeserializeJsonToArray_WithNewtonsoftJson_InvalidJson_ShouldThrowException()
+    {
+        // Arrange
+        var jsonConverter = new NewtonsoftJsonConverter();
+        var serializer = new MappingSerializer(jsonConverter);
+        var invalidJson = "not valid json";
+
+        // Act
+        Action act = () => serializer.DeserializeJsonToArray<MappingModel>(invalidJson);
+
+        // Assert
+        act.Should().Throw<Exception>();
+    }
+
+    [Fact]
+    public void MappingSerializer_DeserializeJsonToArray_WithNewtonsoftJson_ComplexMapping_ShouldDeserializeCorrectly()
+    {
+        // Arrange
+        var jsonConverter = new NewtonsoftJsonConverter();
+        var serializer = new MappingSerializer(jsonConverter);
+        var complexJson =
+            """
+            {
+                "Guid": "12345678-1234-1234-1234-123456789012",
+                "Title": "Test Mapping",
+                "Description": "A test mapping",
+                "Priority": 10,
+                "Request": {
+                    "Path": "/api/test",
+                    "Methods": ["GET", "POST"]
+                },
+                "Response": {
+                    "StatusCode": 201,
+                    "Body": "Test Response"
+                }
+            }
+            """;
+
+        // Act
+        var result = serializer.DeserializeJsonToArray<MappingModel>(complexJson);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Should().HaveCount(1);
+        result[0].Guid.Should().Be(Guid.Parse("12345678-1234-1234-1234-123456789012"));
+        result[0].Title.Should().Be("Test Mapping");
+        result[0].Description.Should().Be("A test mapping");
+        result[0].Priority.Should().Be(10);
+    }
+
+    [Fact]
+    public void MappingSerializer_DeserializeJsonToArray_WithNewtonsoftJson_NullValue_ShouldThrowException()
+    {
+        // Arrange
+        var jsonConverter = new NewtonsoftJsonConverter();
+        var serializer = new MappingSerializer(jsonConverter);
+        var nullJson = "null";
+
+        // Act
+        Action act = () => serializer.DeserializeJsonToArray<MappingModel>(nullJson);
+
+        // Assert
+        act.Should().Throw<Exception>();
+    }
+
+    [Fact]
+    public void MappingSerializer_DeserializeJsonToArray_WithNewtonsoftJson_PrimitiveValue_ShouldThrowInvalidOperationException()
+    {
+        // Arrange
+        var jsonConverter = new NewtonsoftJsonConverter();
+        var serializer = new MappingSerializer(jsonConverter);
+        var primitiveJson = "\"string value\"";
+
+        // Act
+        Action act = () => serializer.DeserializeJsonToArray<MappingModel>(primitiveJson);
+
+        // Assert
+        act.Should().Throw<InvalidOperationException>()
+            .WithMessage("Cannot deserialize the provided value to an array or object.");
+    }
+
+#if NET8_0_OR_GREATER
+    [Fact]
+    public void MappingSerializer_DeserializeJsonToArray_WithSystemTextJson_SingleObject_ShouldReturnArray()
+    {
+        // Arrange
+        var jsonConverter = new SystemTextJsonConverter();
+        var serializer = new MappingSerializer(jsonConverter);
+
+        // Act
+        var result = serializer.DeserializeJsonToArray<MappingModel>(SingleMappingJson);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Should().HaveCount(1);
+        result[0].Guid.Should().Be(Guid.Parse("12345678-1234-1234-1234-123456789012"));
+        result[0].Priority.Should().Be(1);
+    }
+
+    [Fact]
+    public void MappingSerializer_DeserializeJsonToArray_WithSystemTextJson_Array_ShouldReturnArray()
+    {
+        // Arrange
+        var jsonConverter = new SystemTextJsonConverter();
+        var serializer = new MappingSerializer(jsonConverter);
+
+        // Act
+        var result = serializer.DeserializeJsonToArray<MappingModel>(ArrayMappingJson);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Should().HaveCount(2);
+        result[0].Guid.Should().Be(Guid.Parse("12345678-1234-1234-1234-123456789012"));
+        result[0].Priority.Should().Be(1);
+        result[1].Guid.Should().Be(Guid.Parse("87654321-4321-4321-4321-210987654321"));
+        result[1].Priority.Should().Be(2);
+    }
+
+    [Fact]
+    public void MappingSerializer_DeserializeJsonToArray_WithSystemTextJson_EmptyArray_ShouldReturnEmptyArray()
+    {
+        // Arrange
+        var jsonConverter = new SystemTextJsonConverter();
+        var serializer = new MappingSerializer(jsonConverter);
+        var emptyArrayJson = "[]";
+
+        // Act
+        var result = serializer.DeserializeJsonToArray<MappingModel>(emptyArrayJson);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void MappingSerializer_DeserializeJsonToArray_WithSystemTextJson_InvalidJson_ShouldThrowException()
+    {
+        // Arrange
+        var jsonConverter = new SystemTextJsonConverter();
+        var serializer = new MappingSerializer(jsonConverter);
+        var invalidJson = "not valid json";
+
+        // Act
+        Action act = () => serializer.DeserializeJsonToArray<MappingModel>(invalidJson);
+
+        // Assert
+        act.Should().Throw<Exception>();
+    }
+
+    [Fact]
+    public void MappingSerializer_DeserializeJsonToArray_WithSystemTextJson_ComplexMapping_ShouldDeserializeCorrectly()
+    {
+        // Arrange
+        var jsonConverter = new SystemTextJsonConverter();
+        var serializer = new MappingSerializer(jsonConverter);
+        var complexJson =
+            """
+            {
+                "Guid": "12345678-1234-1234-1234-123456789012",
+                "Title": "Test Mapping",
+                "Description": "A test mapping",
+                "Priority": 10,
+                "Request": {
+                    "Path": "/api/test",
+                    "Methods": ["GET", "POST"]
+                },
+                "Response": {
+                    "StatusCode": 201,
+                    "Body": "Test Response"
+                }
+            }
+            """;
+
+        // Act
+        var result = serializer.DeserializeJsonToArray<MappingModel>(complexJson);
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Should().HaveCount(1);
+        result[0].Guid.Should().Be(Guid.Parse("12345678-1234-1234-1234-123456789012"));
+        result[0].Title.Should().Be("Test Mapping");
+        result[0].Description.Should().Be("A test mapping");
+        result[0].Priority.Should().Be(10);
+    }
+
+    [Fact]
+    public void MappingSerializer_DeserializeJsonToArray_WithSystemTextJson_NullValue_ShouldThrowException()
+    {
+        // Arrange
+        var jsonConverter = new SystemTextJsonConverter();
+        var serializer = new MappingSerializer(jsonConverter);
+        var nullJson = "null";
+
+        // Act
+        Action act = () => serializer.DeserializeJsonToArray<MappingModel>(nullJson);
+
+        // Assert
+        act.Should().Throw<Exception>();
+    }
+
+    [Fact]
+    public void MappingSerializer_DeserializeJsonToArray_WithSystemTextJson_PrimitiveValue_ShouldThrowInvalidOperationException()
+    {
+        // Arrange
+        var jsonConverter = new SystemTextJsonConverter();
+        var serializer = new MappingSerializer(jsonConverter);
+        var primitiveJson = "\"string value\"";
+
+        // Act
+        Action act = () => serializer.DeserializeJsonToArray<MappingModel>(primitiveJson);
+
+        // Assert
+        act.Should().Throw<InvalidOperationException>()
+            .WithMessage("Cannot deserialize the provided value to an array or object.");
+    }
+#endif
+}

test/WireMock.Net.Tests/WireMockServerTests.WithBody.cs

@@ -1,21 +1,15 @@
 // Copyright © WireMock.Net
 
 #if !NET452
-using System;
-using System.Collections.Generic;
-using System.IO;
 using System.Net;
 using System.Net.Http;
-using System.Net.Http.Headers;
 using System.Net.Http.Json;
 using System.Text;
-using System.Threading.Tasks;
 using FluentAssertions;
 using WireMock.Matchers;
 using WireMock.RequestBuilders;
 using WireMock.ResponseBuilders;
 using WireMock.Server;
-using Xunit;
 
 namespace WireMock.Net.Tests;
 
@@ -35,11 +29,10 @@ public partial class WireMockServerTests
             Request.Create()
                 .WithPath("/a")
                 .WithBody(
-                    new IMatcher[]
-                    {
+                    [
                         new JmesPathMatcher("requestId == '1'"),
                         new JmesPathMatcher("value == 'A'")
-                    },
+                    ],
                     MatchOperator.And
                 )
                 .UsingPost()
@@ -50,11 +43,10 @@ public partial class WireMockServerTests
                 Request.Create()
                     .WithPath("/a")
                     .WithBody(
-                        new IMatcher[]
-                        {
+                        [
                             new JmesPathMatcher("requestId == '2'"),
                             new JmesPathMatcher("value == 'A'")
-                        },
+                        ],
                         MatchOperator.And
                     )
                     .UsingPost()
@@ -82,12 +74,11 @@ public partial class WireMockServerTests
                 Request.Create()
                     .WithPath("/a")
                     .WithBody(
-                        new IMatcher[]
-                        {
+                        [
                             new JmesPathMatcher("extra == 'X'"),
                             new JmesPathMatcher("requestId == '1'"),
                             new JmesPathMatcher("value == 'A'")
-                        },
+                        ],
                         MatchOperator.And
                     )
                     .UsingPost()
@@ -99,11 +90,10 @@ public partial class WireMockServerTests
                 Request.Create()
                     .WithPath("/a")
                     .WithBody(
-                        new IMatcher[]
-                        {
+                        [
                             new JmesPathMatcher("requestId == '1'"),
                             new JmesPathMatcher("value == 'A'")
-                        },
+                        ],
                         MatchOperator.And
                     )
                     .UsingPost()
@@ -189,6 +179,7 @@ public partial class WireMockServerTests
                       {"jsonrpc":"2.0","id":"{{request.bodyAsJson.id}}","result":{"protocolVersion":"2024-11-05","capabilities":{"logging":{},"prompts":{"listChanged":true},"resources":{"subscribe":true,"listChanged":true},"tools":{"listChanged":true}},"serverInfo":{"name":"ExampleServer","version":"1.0.0"}}}
                       """)
             .WithStatusCode(200)
+            .WithTransformer(true)
         );
 
         // Act
@@ -200,15 +191,47 @@ public partial class WireMockServerTests
         // Assert
         response.StatusCode.Should().Be(HttpStatusCode.OK);
 
-        var responseText = await response.RequestMessage!.Content!.ReadAsStringAsync();
+        var responseText = await response.Content.ReadAsStringAsync();
         responseText.Should().Contain("ec475f56d4694b48bc737500ba575b35-1");
     }
 
+#if NET6_0_OR_GREATER
+    [Fact]
+    public async Task WireMockServer_WithBodyAsJson_Using_PostAsync_And_JsonPartialWildcardMatcher_And_SystemTextJson_ShouldMatch()
+    {
+        // Arrange
+        using var server = WireMockServer.Start(x => x.DefaultJsonSerializer = new JsonConverter.System.Text.Json.SystemTextJsonConverter() );
+
+        var matcher = new JsonPartialWildcardMatcher(new { id = "^[a-f0-9]{32}-[0-9]$" }, ignoreCase: true, regex: true);
+        server.Given(Request.Create()
+            .WithHeader("Content-Type", "application/json*")
+            .UsingPost()
+            .WithPath("/system-text-json")
+            .WithBody(matcher)
+        )
+        .RespondWith(Response.Create()
+            .WithBody("OK")
+        );
+
+        // Act
+        var content = """{"id":"ec475f56d4694b48bc737500ba575b35-1"}""";
+        var response = await new HttpClient()
+            .PostAsync($"{server.Url}/system-text-json", new StringContent(content, Encoding.UTF8, "application/json"))
+            .ConfigureAwait(false);
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.OK);
+
+        var responseText = await response.Content.ReadAsStringAsync();
+        responseText.Should().Contain("OK");
+    }
+#endif
+
     [Fact]
     public async Task WireMockServer_WithBodyAsFormUrlEncoded_Using_PostAsync_And_WithFunc()
     {
         // Arrange
-        var server = WireMockServer.Start();
+        using var server = WireMockServer.Start();
         server.Given(
             Request.Create()
                 .UsingPost()
@@ -220,7 +243,7 @@ public partial class WireMockServerTests
             );
 
         // Act
-        var content = new FormUrlEncodedContent(new[] { new KeyValuePair<string, string>("key1", "value1") });
+        var content = new FormUrlEncodedContent([new KeyValuePair<string, string>("key1", "value1")]);
         var response = await new HttpClient()
             .PostAsync($"{server.Url}/foo", content)
 ;