Merge branch 'master' into SystemTextJsonMatcher

src/WireMock.Net.Minimal/Owin/IWireMockMiddlewareOptions.cs

@@ -2,6 +2,7 @@
 
 using System.Collections.Concurrent;
 using System.Security.Cryptography.X509Certificates;
+using JsonConverter.Abstractions;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.DependencyInjection;
 using WireMock.Handlers;
@@ -99,4 +100,12 @@ internal interface IWireMockMiddlewareOptions
     /// WebSocket settings.
     /// </summary>
     WebSocketSettings? WebSocketSettings { get; set; }
+
+    /// <summary>
+    /// Gets or sets the default JSON converter used for serialization.
+    /// </summary>
+    /// <remarks>
+    /// Set this property to customize how objects are serialized to and deserialized from JSON during mapping.
+    /// </remarks>
+    IJsonConverter DefaultJsonSerializer { get; set; }
 }

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

@@ -3,249 +3,242 @@
 using System.Globalization;
 using System.Net;
 using System.Text;
+using JsonConverter.Abstractions;
 using Microsoft.AspNetCore.Http;
-using Newtonsoft.Json;
 using RandomDataGenerator.FieldOptions;
 using RandomDataGenerator.Randomizers;
-using Stef.Validation;
 using WireMock.Http;
 using WireMock.ResponseBuilders;
 using WireMock.ResponseProviders;
 using WireMock.Types;
 using WireMock.Util;
 
-namespace WireMock.Owin.Mappers
+namespace WireMock.Owin.Mappers;
+
+/// <summary>
+/// OwinResponseMapper
+/// </summary>
+internal class OwinResponseMapper(IWireMockMiddlewareOptions options) : IOwinResponseMapper
 {
-    /// <summary>
-    /// OwinResponseMapper
-    /// </summary>
-    internal class OwinResponseMapper : IOwinResponseMapper
+    private readonly IRandomizerNumber<double> _randomizerDouble = RandomizerFactory.GetRandomizer(new FieldOptionsDouble { Min = 0, Max = 1 });
+    private readonly IRandomizerBytes _randomizerBytes = RandomizerFactory.GetRandomizer(new FieldOptionsBytes { Min = 100, Max = 200 });
+    private readonly Encoding _utf8NoBom = new UTF8Encoding(false);
+
+    // https://msdn.microsoft.com/en-us/library/78h415ay(v=vs.110).aspx
+    private static readonly IDictionary<string, Action<HttpResponse, bool, WireMockList<string>>> ResponseHeadersToFix =
+        new Dictionary<string, Action<HttpResponse, bool, WireMockList<string>>>(StringComparer.OrdinalIgnoreCase)
+        {
+            { HttpKnownHeaderNames.ContentType, (r, _, v) => r.ContentType = v.FirstOrDefault() },
+            { HttpKnownHeaderNames.ContentLength, (r, hasBody, v) =>
+                {
+                    // Only set the Content-Length header if the response does not have a body
+                    if (!hasBody && long.TryParse(v.FirstOrDefault(), out var contentLength))
+                    {
+                        r.ContentLength = contentLength;
+                    }
+                }
+            }
+        };
+
+    /// <inheritdoc />
+    public async Task MapAsync(IResponseMessage? responseMessage, HttpResponse response)
     {
-        private readonly IRandomizerNumber<double> _randomizerDouble = RandomizerFactory.GetRandomizer(new FieldOptionsDouble { Min = 0, Max = 1 });
-        private readonly IRandomizerBytes _randomizerBytes = RandomizerFactory.GetRandomizer(new FieldOptionsBytes { Min = 100, Max = 200 });
-        private readonly IWireMockMiddlewareOptions _options;
-        private readonly Encoding _utf8NoBom = new UTF8Encoding(false);
-
-        // https://msdn.microsoft.com/en-us/library/78h415ay(v=vs.110).aspx
-        private static readonly IDictionary<string, Action<HttpResponse, bool, WireMockList<string>>> ResponseHeadersToFix =
-            new Dictionary<string, Action<HttpResponse, bool, WireMockList<string>>>(StringComparer.OrdinalIgnoreCase)
-            {
-                { HttpKnownHeaderNames.ContentType, (r, _, v) => r.ContentType = v.FirstOrDefault() },
-                { HttpKnownHeaderNames.ContentLength, (r, hasBody, v) =>
-                    {
-                        // Only set the Content-Length header if the response does not have a body
-                        if (!hasBody && long.TryParse(v.FirstOrDefault(), out var contentLength))
-                        {
-                            r.ContentLength = contentLength;
-                        }
-                    }
-                }
-            };
-
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        /// <param name="options">The IWireMockMiddlewareOptions.</param>
-        public OwinResponseMapper(IWireMockMiddlewareOptions options)
+        if (responseMessage == null || responseMessage is WebSocketHandledResponse)
         {
-            _options = Guard.NotNull(options);
+            return;
         }
 
-        /// <inheritdoc />
-        public async Task MapAsync(IResponseMessage? responseMessage, HttpResponse response)
+        var bodyData = responseMessage.BodyData;
+        if (bodyData?.GetDetectedBodyType() == BodyType.SseString)
         {
-            if (responseMessage == null || responseMessage is WebSocketHandledResponse)
-            {
-                return;
-            }
+            await HandleSseStringAsync(responseMessage, response, bodyData);
+            return;
+        }
 
-            var bodyData = responseMessage.BodyData;
-            if (bodyData?.GetDetectedBodyType() == BodyType.SseString)
-            {
-                await HandleSseStringAsync(responseMessage, response, bodyData);
-                return;
-            }
+        byte[]? bytes;
+        switch (responseMessage.FaultType)
+        {
+            case FaultType.EMPTY_RESPONSE:
+                bytes = IsFault(responseMessage) ? [] : await GetNormalBodyAsync(responseMessage).ConfigureAwait(false);
+                break;
 
-            byte[]? bytes;
-            switch (responseMessage.FaultType)
-            {
-                case FaultType.EMPTY_RESPONSE:
-                    bytes = IsFault(responseMessage) ? [] : await GetNormalBodyAsync(responseMessage).ConfigureAwait(false);
-                    break;
-
-                case FaultType.MALFORMED_RESPONSE_CHUNK:
-                    bytes = await GetNormalBodyAsync(responseMessage).ConfigureAwait(false) ?? [];
-                    if (IsFault(responseMessage))
-                    {
-                        bytes = bytes.Take(bytes.Length / 2).Union(_randomizerBytes.Generate()).ToArray();
-                    }
-                    break;
-
-                default:
-                    bytes = await GetNormalBodyAsync(responseMessage).ConfigureAwait(false);
-                    break;
-            }
-
-            if (responseMessage.StatusCode is HttpStatusCode or int)
-            {
-                response.StatusCode = MapStatusCode((int) responseMessage.StatusCode);
-            }
-            else if (responseMessage.StatusCode is string statusCodeAsString)
-            {
-                // Note: this case will also match on null
-                _ = int.TryParse(statusCodeAsString, out var statusCodeTypeAsInt);
-                response.StatusCode = MapStatusCode(statusCodeTypeAsInt);
-            }
-
-            SetResponseHeaders(responseMessage, bytes != null, response);
-
-            if (bytes != null)
-            {
-                try
+            case FaultType.MALFORMED_RESPONSE_CHUNK:
+                bytes = await GetNormalBodyAsync(responseMessage).ConfigureAwait(false) ?? [];
+                if (IsFault(responseMessage))
                 {
-                    await response.Body.WriteAsync(bytes, 0, bytes.Length).ConfigureAwait(false);
+                    bytes = bytes.Take(bytes.Length / 2).Union(_randomizerBytes.Generate()).ToArray();
                 }
-                catch (Exception ex)
+                break;
+
+            default:
+                bytes = await GetNormalBodyAsync(responseMessage).ConfigureAwait(false);
+                break;
+        }
+
+        if (responseMessage.StatusCode is HttpStatusCode or int)
+        {
+            response.StatusCode = MapStatusCode((int)responseMessage.StatusCode);
+        }
+        else if (responseMessage.StatusCode is string statusCodeAsString)
+        {
+            // Note: this case will also match on null
+            _ = int.TryParse(statusCodeAsString, out var statusCodeTypeAsInt);
+            response.StatusCode = MapStatusCode(statusCodeTypeAsInt);
+        }
+
+        SetResponseHeaders(responseMessage, bytes != null, response);
+
+        if (bytes != null)
+        {
+            try
+            {
+                await response.Body.WriteAsync(bytes, 0, bytes.Length).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                options.Logger.Warn("Error writing response body. Exception : {0}", ex);
+            }
+        }
+
+        SetResponseTrailingHeaders(responseMessage, response);
+    }
+
+    private static async Task HandleSseStringAsync(IResponseMessage responseMessage, HttpResponse response, IBodyData bodyData)
+    {
+        if (bodyData.SseStringQueue == null)
+        {
+            return;
+        }
+
+        SetResponseHeaders(responseMessage, true, response);
+
+        string? text;
+        do
+        {
+            if (bodyData.SseStringQueue.TryRead(out text))
+            {
+                await response.WriteAsync(text);
+                await response.Body.FlushAsync();
+            }
+        } while (text != null);
+    }
+
+    private int MapStatusCode(int code)
+    {
+        if (options.AllowOnlyDefinedHttpStatusCodeInResponse == true && !Enum.IsDefined(typeof(HttpStatusCode), code))
+        {
+            return (int)HttpStatusCode.OK;
+        }
+
+        return code;
+    }
+
+    private bool IsFault(IResponseMessage responseMessage)
+    {
+        return responseMessage.FaultPercentage == null || _randomizerDouble.Generate() <= responseMessage.FaultPercentage;
+    }
+
+    private async Task<byte[]?> GetNormalBodyAsync(IResponseMessage responseMessage)
+    {
+        var bodyData = responseMessage.BodyData;
+        switch (bodyData?.GetDetectedBodyType())
+        {
+            case BodyType.String:
+            case BodyType.FormUrlEncoded:
+                return (bodyData.Encoding ?? _utf8NoBom).GetBytes(bodyData.BodyAsString!);
+
+            case BodyType.Json:
+                var jsonConverterOptions = new JsonConverterOptions
                 {
-                    _options.Logger.Warn("Error writing response body. Exception : {0}", ex);
-                }
-            }
+                    WriteIndented = bodyData.BodyAsJsonIndented == true,
+                    IgnoreNullValues = true
+                };
 
-            SetResponseTrailingHeaders(responseMessage, response);
-        }
+                var jsonBody = options.DefaultJsonSerializer.Serialize(bodyData.BodyAsJson!, jsonConverterOptions);
+                return (bodyData.Encoding ?? _utf8NoBom).GetBytes(jsonBody);
 
-        private static async Task HandleSseStringAsync(IResponseMessage responseMessage, HttpResponse response, IBodyData bodyData)
-        {
-            if (bodyData.SseStringQueue == null)
-            {
-                return;
-            }
-
-            SetResponseHeaders(responseMessage, true, response);
-
-            string? text;
-            do
-            {
-                if (bodyData.SseStringQueue.TryRead(out text))
+            case BodyType.ProtoBuf:
+                if (TypeLoader.TryLoadStaticInstance<IProtoBufUtils>(out var protoBufUtils))
                 {
-                    await response.WriteAsync(text);
-                    await response.Body.FlushAsync();
+                    var protoDefinitions = bodyData.ProtoDefinition?.Invoke().Texts;
+                    return await protoBufUtils.GetProtoBufMessageWithHeaderAsync(protoDefinitions, bodyData.ProtoBufMessageType, bodyData.BodyAsJson).ConfigureAwait(false);
                 }
-            } while (text != null);
+                break;
+
+            case BodyType.Bytes:
+                return bodyData.BodyAsBytes;
+
+            case BodyType.File:
+                return options.FileSystemHandler?.ReadResponseBodyAsFile(bodyData.BodyAsFile!);
+
+            case BodyType.MultiPart:
+                options.Logger.Warn("MultiPart body type is not handled!");
+                break;
+
+            case BodyType.None:
+                break;
         }
 
-        private int MapStatusCode(int code)
+        return null;
+    }
+
+    private static void SetResponseHeaders(IResponseMessage responseMessage, bool hasBody, HttpResponse response)
+    {
+        // Force setting the Date header (#577)
+        AppendResponseHeader(
+            response,
+            HttpKnownHeaderNames.Date,
+            [DateTime.UtcNow.ToString(CultureInfo.InvariantCulture.DateTimeFormat.RFC1123Pattern, CultureInfo.InvariantCulture)]
+        );
+
+        // Set other headers
+        foreach (var item in responseMessage.Headers!)
         {
-            if (_options.AllowOnlyDefinedHttpStatusCodeInResponse == true && !Enum.IsDefined(typeof(HttpStatusCode), code))
+            var headerName = item.Key;
+            var value = item.Value;
+            if (ResponseHeadersToFix.TryGetValue(headerName, out var action))
             {
-                return (int)HttpStatusCode.OK;
+                action.Invoke(response, hasBody, value);
             }
-
-            return code;
-        }
-
-        private bool IsFault(IResponseMessage responseMessage)
-        {
-            return responseMessage.FaultPercentage == null || _randomizerDouble.Generate() <= responseMessage.FaultPercentage;
-        }
-
-        private async Task<byte[]?> GetNormalBodyAsync(IResponseMessage responseMessage)
-        {
-            var bodyData = responseMessage.BodyData;
-            switch (bodyData?.GetDetectedBodyType())
+            else
             {
-                case BodyType.String:
-                case BodyType.FormUrlEncoded:
-                    return (bodyData.Encoding ?? _utf8NoBom).GetBytes(bodyData.BodyAsString!);
-
-                case BodyType.Json:
-                    var formatting = bodyData.BodyAsJsonIndented == true ? Formatting.Indented : Formatting.None;
-                    var jsonBody = JsonConvert.SerializeObject(bodyData.BodyAsJson, new JsonSerializerSettings { Formatting = formatting, NullValueHandling = NullValueHandling.Ignore });
-                    return (bodyData.Encoding ?? _utf8NoBom).GetBytes(jsonBody);
-
-                case BodyType.ProtoBuf:
-                    if (TypeLoader.TryLoadStaticInstance<IProtoBufUtils>(out var protoBufUtils))
-                    {
-                        var protoDefinitions = bodyData.ProtoDefinition?.Invoke().Texts;
-                        return await protoBufUtils.GetProtoBufMessageWithHeaderAsync(protoDefinitions, bodyData.ProtoBufMessageType, bodyData.BodyAsJson).ConfigureAwait(false);
-                    }
-                    break;
-
-                case BodyType.Bytes:
-                    return bodyData.BodyAsBytes;
-
-                case BodyType.File:
-                    return _options.FileSystemHandler?.ReadResponseBodyAsFile(bodyData.BodyAsFile!);
-
-                case BodyType.MultiPart:
-                    _options.Logger.Warn("MultiPart body type is not handled!");
-                    break;
-
-                case BodyType.None:
-                    break;
-            }
-
-            return null;
-        }
-
-        private static void SetResponseHeaders(IResponseMessage responseMessage, bool hasBody, HttpResponse response)
-        {
-            // Force setting the Date header (#577)
-            AppendResponseHeader(
-                response,
-                HttpKnownHeaderNames.Date,
-                [DateTime.UtcNow.ToString(CultureInfo.InvariantCulture.DateTimeFormat.RFC1123Pattern, CultureInfo.InvariantCulture)]
-            );
-
-            // Set other headers
-            foreach (var item in responseMessage.Headers!)
-            {
-                var headerName = item.Key;
-                var value = item.Value;
-                if (ResponseHeadersToFix.TryGetValue(headerName, out var action))
+                // Check if this response header can be added (#148, #227 and #720)
+                if (!HttpKnownHeaderNames.IsRestrictedResponseHeader(headerName))
                 {
-                    action.Invoke(response, hasBody, value);
-                }
-                else
-                {
-                    // Check if this response header can be added (#148, #227 and #720)
-                    if (!HttpKnownHeaderNames.IsRestrictedResponseHeader(headerName))
-                    {
-                        AppendResponseHeader(response, headerName, value.ToArray());
-                    }
+                    AppendResponseHeader(response, headerName, value.ToArray());
                 }
             }
         }
-
-        private static void SetResponseTrailingHeaders(IResponseMessage responseMessage, HttpResponse response)
-        {
-            if (responseMessage.TrailingHeaders == null)
-            {
-                return;
-            }
-
-#if TRAILINGHEADERS
-            foreach (var (headerName, value) in responseMessage.TrailingHeaders)
-            {
-                if (ResponseHeadersToFix.TryGetValue(headerName, out var action))
-                {
-                    action.Invoke(response, false, value);
-                }
-                else
-                {
-                    // Check if this trailing header can be added to the response
-                    if (response.SupportsTrailers() && !HttpKnownHeaderNames.IsRestrictedResponseHeader(headerName))
-                    {
-                        response.AppendTrailer(headerName, new Microsoft.Extensions.Primitives.StringValues(value.ToArray()));
-                    }
-                }
-            }
-#endif
-        }
-
-        private static void AppendResponseHeader(HttpResponse response, string headerName, string[] values)
-        {
-            response.Headers.Append(headerName, values);
-        }
+    }
+
+    private static void SetResponseTrailingHeaders(IResponseMessage responseMessage, HttpResponse response)
+    {
+        if (responseMessage.TrailingHeaders == null)
+        {
+            return;
+        }
+
+#if TRAILINGHEADERS
+        foreach (var (headerName, value) in responseMessage.TrailingHeaders)
+        {
+            if (ResponseHeadersToFix.TryGetValue(headerName, out var action))
+            {
+                action.Invoke(response, false, value);
+            }
+            else
+            {
+                // Check if this trailing header can be added to the response
+                if (response.SupportsTrailers() && !HttpKnownHeaderNames.IsRestrictedResponseHeader(headerName))
+                {
+                    response.AppendTrailer(headerName, new Microsoft.Extensions.Primitives.StringValues(value.ToArray()));
+                }
+            }
+        }
+#endif
+    }
+
+    private static void AppendResponseHeader(HttpResponse response, string headerName, string[] values)
+    {
+        response.Headers.Append(headerName, values);
     }
 }

src/WireMock.Net.Minimal/Owin/WireMockMiddlewareOptions.cs

@@ -2,6 +2,8 @@
 
 using System.Collections.Concurrent;
 using System.Security.Cryptography.X509Certificates;
+using JsonConverter.Abstractions;
+using JsonConverter.Newtonsoft.Json;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.DependencyInjection;
 using WireMock.Handlers;
@@ -108,5 +110,9 @@ internal class WireMockMiddlewareOptions : IWireMockMiddlewareOptions
     /// <inheritdoc />
     public ConcurrentDictionary<Guid, WebSocketConnectionRegistry> WebSocketRegistries { get; } = new();
 
+    /// <inheritdoc />
     public WebSocketSettings? WebSocketSettings { get; set; }
+
+    /// <inheritdoc />
+    public IJsonConverter DefaultJsonSerializer { get; set; } = new NewtonsoftJsonConverter();
 }

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

@@ -414,6 +414,7 @@ public partial class WireMockServer : IWireMockServer
         _options.CorsPolicyOptions = _settings.CorsPolicyOptions;
         _options.ClientCertificateMode = (Microsoft.AspNetCore.Server.Kestrel.Https.ClientCertificateMode)_settings.ClientCertificateMode;
         _options.AcceptAnyClientCertificate = _settings.AcceptAnyClientCertificate;
+        _options.DefaultJsonSerializer = _settings.DefaultJsonSerializer;
 
         _httpServer = new AspNetCoreSelfHost(_options, urlOptions);
         var startTask = _httpServer.StartAsync();