Add SystemTextJsonMatchers (#1447)

* SystemTextJsonMatcher * , * . * new projectx * Update test/WireMock.Net.Tests/Pact/PactTests.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update test/WireMock.Net.Tests/WebSockets/WebSocketIntegrationTests.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update src/WireMock.Net/WireMock.Net.csproj Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update src/WireMock.Net.Minimal/Properties/AssemblyInfo.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * . * more tests * . * . * x * ... * . * fix tests * 0.11.0 * . * delete jsonutils.cs * s * fix findings * Apply suggestions from code review Co-authored-by: Copilot Autofix powered by AI <223894421+github-code-quality[bot]@users.noreply.github.com> * Potential fix for pull request finding 'Missing Dispose call on local IDisposable' Co-authored-by: Copilot Autofix powered by AI <223894421+github-code-quality[bot]@users.noreply.github.com> * JsonConverter 0.12.0 * -- tools --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Co-authored-by: Copilot Autofix powered by AI <223894421+github-code-quality[bot]@users.noreply.github.com>
2026-05-30 11:40:47 +02:00 · 2026-05-29 20:19:51 +02:00
parent fed1c87663
commit 36b0a93a6c
68 changed files with 4202 additions and 976 deletions
@@ -1,6 +1,5 @@
 // Copyright © WireMock.Net

-using System.Linq;
 using Newtonsoft.Json.Linq;
 using WireMock.Util;

@@ -0,0 +1,173 @@
+// Copyright © WireMock.Net
+
+using System.Text.Json;
+using WireMock.Util;
+
+namespace WireMock.Matchers;
+
+/// <summary>
+/// Generic AbstractSystemTextJsonPartialMatcher - uses System.Text.Json instead of Newtonsoft.Json.
+/// </summary>
+public abstract class AbstractSystemTextJsonPartialMatcher : SystemTextJsonMatcher
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AbstractSystemTextJsonPartialMatcher"/> class.
+    /// </summary>
+    protected AbstractSystemTextJsonPartialMatcher(string value, bool ignoreCase = false, bool regex = false)
+        : base(value, ignoreCase, regex)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AbstractSystemTextJsonPartialMatcher"/> class.
+    /// </summary>
+    protected AbstractSystemTextJsonPartialMatcher(object value, bool ignoreCase = false, bool regex = false)
+        : base(value, ignoreCase, regex)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AbstractSystemTextJsonPartialMatcher"/> class.
+    /// </summary>
+    protected AbstractSystemTextJsonPartialMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false, bool regex = false)
+        : base(matchBehaviour, value, ignoreCase, regex)
+    {
+    }
+
+    /// <inheritdoc />
+    protected override bool IsMatch(JsonElement value, JsonElement? input)
+    {
+        if (input == null)
+        {
+            return false;
+        }
+
+        var inputElement = input.Value;
+
+        // Regex on a string value
+        if (Regex && value.ValueKind == JsonValueKind.String)
+        {
+            var valueAsString = value.GetString()!;
+            var inputAsString = GetStringValue(inputElement);
+
+            var (valid, result) = RegexUtils.MatchRegex(valueAsString, inputAsString);
+            if (valid)
+            {
+                return result;
+            }
+        }
+
+        // Guid comparison: both strings, both parseable as Guid
+        if (value.ValueKind == JsonValueKind.String && inputElement.ValueKind == JsonValueKind.String)
+        {
+            var valueStr = value.GetString()!;
+            var inputStr = inputElement.GetString()!;
+            if (Guid.TryParse(valueStr, out var vg) && Guid.TryParse(inputStr, out var ig))
+            {
+                return IsMatch(vg.ToString(), ig.ToString());
+            }
+        }
+
+        // Type mismatch (after regex/guid checks)
+        if (value.ValueKind != inputElement.ValueKind)
+        {
+            return false;
+        }
+
+        switch (value.ValueKind)
+        {
+            case JsonValueKind.Object:
+            {
+                var nestedValues = value.EnumerateObject().ToArray();
+                if (nestedValues.Length == 0)
+                {
+                    return true;
+                }
+
+                return nestedValues.All(pair =>
+                {
+                    var selected = SelectElement(inputElement, pair.Name);
+                    return selected != null && IsMatch(pair.Value, selected.Value);
+                });
+            }
+
+            case JsonValueKind.Array:
+            {
+                var valuesArray = value.EnumerateArray().ToArray();
+                if (valuesArray.Length == 0)
+                {
+                    return true;
+                }
+
+                var tokenArray = inputElement.EnumerateArray().ToArray();
+                if (tokenArray.Length == 0)
+                {
+                    return false;
+                }
+
+                return valuesArray.All(subFilter => tokenArray.Any(subToken => IsMatch(subFilter, subToken)));
+            }
+
+            default:
+                return IsMatch(GetStringValue(value), GetStringValue(inputElement));
+        }
+    }
+
+    /// <summary>
+    /// Check if two strings are a match (matching can be done exact or wildcard).
+    /// </summary>
+    protected abstract bool IsMatch(string value, string input);
+
+    /// <summary>
+    /// Selects a <see cref="JsonElement"/> from an object using a key that may be a plain property name,
+    /// a dotted path (e.g. "a.b.c") or bracket notation (e.g. "['name.with.dot']"),
+    /// mirroring Newtonsoft's <c>SelectToken</c> + direct indexer fallback.
+    /// </summary>
+    private static JsonElement? SelectElement(JsonElement input, string key)
+    {
+        if (input.ValueKind != JsonValueKind.Object)
+        {
+            return null;
+        }
+
+        // Direct property access (also handles keys containing colons or dots that are literal property names)
+        if (input.TryGetProperty(key, out var direct))
+        {
+            return direct;
+        }
+
+        // Bracket notation: ['property.name.with.dots']
+        if (key.StartsWith("['") && key.EndsWith("']"))
+        {
+            var propertyName = key.Substring(2, key.Length - 4);
+            return input.TryGetProperty(propertyName, out var bracketValue) ? bracketValue : null;
+        }
+
+        // Dotted path: a.b.c
+        if (key.Contains('.'))
+        {
+            var parts = key.Split('.');
+            var current = input;
+            foreach (var part in parts)
+            {
+                if (current.ValueKind != JsonValueKind.Object || !current.TryGetProperty(part, out var next))
+                {
+                    return null;
+                }
+
+                current = next;
+            }
+
+            return current;
+        }
+
+        return null;
+    }
+
+    private static string GetStringValue(JsonElement element)
+    {
+        return element.ValueKind == JsonValueKind.String
+            ? element.GetString()!
+            : element.GetRawText();
+    }
+}
@@ -1,6 +1,5 @@
 // Copyright © WireMock.Net

-using System.Linq;
 using AnyOfTypes;
 using Newtonsoft.Json.Linq;
 using Stef.Validation;
@@ -13,9 +12,8 @@ namespace WireMock.Matchers;
 /// <summary>
 /// JsonPathMatcher
 /// </summary>
-/// <seealso cref="IStringMatcher" />
-/// <seealso cref="IObjectMatcher" />
-public class JsonPathMatcher : IStringMatcher, IObjectMatcher
+/// <seealso cref="IJsonPathMatcher" />
+public class JsonPathMatcher : IJsonPathMatcher
 {
    private readonly AnyOf<string, StringPattern>[] _patterns;

@@ -1,11 +1,12 @@
 // Copyright © WireMock.Net

-using System.Linq;
+using System.Collections;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using Stef.Validation;
 using WireMock.Extensions;
+using WireMock.Serialization;
 using WireMock.Util;
-using JsonUtils = WireMock.Util.JsonUtils;

 namespace WireMock.Matchers;

@@ -69,7 +70,7 @@ public class JsonMatcher : IJsonMatcher
        Regex = regex;

        Value = value;
-        _valueAsJToken = JsonUtils.ConvertValueToJToken(value);
+        _valueAsJToken = ConvertValueToJToken(value);
    }

    /// <inheritdoc />
@@ -83,7 +84,7 @@ public class JsonMatcher : IJsonMatcher
        {
            try
            {
-                var inputAsJToken = JsonUtils.ConvertValueToJToken(input);
+                var inputAsJToken = ConvertValueToJToken(input);

                var match = IsMatch(RenameJToken(_valueAsJToken), RenameJToken(inputAsJToken));
                score = MatchScores.ToScore(match);
@@ -103,7 +104,7 @@ public class JsonMatcher : IJsonMatcher
        return $"new {Name}" +
               $"(" +
               $"{MatchBehaviour.GetFullyQualifiedEnumValue()}, " +
-               $"{CSharpFormatter.ConvertToAnonymousObjectDefinition(Value, 3)}, " + 
+               $"{CSharpFormatter.ConvertToAnonymousObjectDefinition(Value, 3)}, " +
               $"{CSharpFormatter.ToCSharpBooleanLiteral(IgnoreCase)}, " +
               $"{CSharpFormatter.ToCSharpBooleanLiteral(Regex)}" +
               $")";
@@ -241,6 +242,18 @@ public class JsonMatcher : IJsonMatcher
        return new JObject(renamedProperties);
    }

+    private static JToken ConvertValueToJToken(object value)
+    {
+        // Check if JToken, string, IEnumerable or object
+        return value switch
+        {
+            JToken tokenValue => tokenValue,
+            string stringValue => JsonConvert.DeserializeObject<JToken>(stringValue, JsonSerializationConstants.JsonDeserializerSettingsWithDateParsingNone)!,
+            IEnumerable enumerableValue => JArray.FromObject(enumerableValue),
+            _ => JObject.FromObject(value),
+        };
+    }
+
    private static string? ToUpper(string? input)
    {
        return input?.ToUpperInvariant();
@@ -1,6 +1,5 @@
 // Copyright © WireMock.Net

-using System.Linq;
 using Stef.Validation;
 using WireMock.Matchers.Helpers;
 using WireMock.Util;
@@ -0,0 +1,282 @@
+// Copyright © WireMock.Net
+
+using System.Collections;
+using System.Text.Json;
+using Stef.Validation;
+using WireMock.Extensions;
+using WireMock.Util;
+
+namespace WireMock.Matchers;
+
+/// <summary>
+/// SystemTextJsonMatcher - behaves the same as <see cref="JsonMatcher"/> but uses System.Text.Json instead of Newtonsoft.Json.
+/// </summary>
+public class SystemTextJsonMatcher : IJsonMatcher
+{
+    private static readonly JsonSerializerOptions DefaultSerializerOptions = new()
+    {
+        PropertyNameCaseInsensitive = false
+    };
+
+    /// <inheritdoc />
+    public virtual string Name => nameof(SystemTextJsonMatcher);
+
+    /// <inheritdoc />
+    public object Value { get; }
+
+    /// <inheritdoc />
+    public MatchBehaviour MatchBehaviour { get; }
+
+    /// <inheritdoc cref="IIgnoreCaseMatcher.IgnoreCase"/>
+    public bool IgnoreCase { get; }
+
+    /// <summary>
+    /// Support Regex
+    /// </summary>
+    public bool Regex { get; }
+
+    private readonly JsonElement _valueAsJsonElement;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SystemTextJsonMatcher"/> 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>
+    public SystemTextJsonMatcher(string value, bool ignoreCase = false, bool regex = false)
+        : this(MatchBehaviour.AcceptOnMatch, value, ignoreCase, regex)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SystemTextJsonMatcher"/> class.
+    /// </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>
+    /// <param name="regex">Support Regex.</param>
+    public SystemTextJsonMatcher(object value, bool ignoreCase = false, bool regex = false)
+        : this(MatchBehaviour.AcceptOnMatch, value, ignoreCase, regex)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SystemTextJsonMatcher"/> class.
+    /// </summary>
+    /// <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>
+    /// <param name="regex">Support Regex.</param>
+    public SystemTextJsonMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false, bool regex = false)
+    {
+        Guard.NotNull(value);
+
+        MatchBehaviour = matchBehaviour;
+        IgnoreCase = ignoreCase;
+        Regex = regex;
+
+        Value = value;
+        _valueAsJsonElement = ConvertToJsonElement(value);
+    }
+
+    /// <inheritdoc />
+    public MatchResult IsMatch(object? input)
+    {
+        var score = MatchScores.Mismatch;
+        Exception? error = null;
+
+        // When input is null or byte[], return Mismatch.
+        if (input != null && input is not byte[])
+        {
+            try
+            {
+                var inputAsJsonElement = ConvertToJsonElement(input);
+
+                var match = IsMatch(NormalizeElement(_valueAsJsonElement), NormalizeElement(inputAsJsonElement));
+                score = MatchScores.ToScore(match);
+            }
+            catch (Exception ex)
+            {
+                error = ex;
+            }
+        }
+
+        return MatchResult.From(Name, MatchBehaviourHelper.Convert(MatchBehaviour, score), error);
+    }
+
+    /// <inheritdoc />
+    public virtual string GetCSharpCodeArguments()
+    {
+        return $"new {Name}" +
+               $"(" +
+               $"{MatchBehaviour.GetFullyQualifiedEnumValue()}, " +
+               $"{CSharpFormatter.ConvertToAnonymousObjectDefinition(Value, 3)}, " +
+               $"{CSharpFormatter.ToCSharpBooleanLiteral(IgnoreCase)}, " +
+               $"{CSharpFormatter.ToCSharpBooleanLiteral(Regex)}" +
+               $")";
+    }
+
+    /// <summary>
+    /// Compares the input against the matcher value
+    /// </summary>
+    protected virtual bool IsMatch(JsonElement value, JsonElement? input)
+    {
+        if (input == null)
+        {
+            return false;
+        }
+
+        var inputElement = input.Value;
+
+        // If using Regex and the value is a string, use the MatchRegex method.
+        if (Regex && value.ValueKind == JsonValueKind.String)
+        {
+            var valueAsString = value.GetString()!;
+            var inputAsString = inputElement.ValueKind == JsonValueKind.String
+                ? inputElement.GetString()!
+                : inputElement.GetRawText();
+
+            var (valid, result) = RegexUtils.MatchRegex(valueAsString, inputAsString);
+            if (valid)
+            {
+                return result;
+            }
+        }
+
+        // If the value is a Guid (string) and input is a string, or vice versa, compare as strings.
+        if (value.ValueKind == JsonValueKind.String && inputElement.ValueKind == JsonValueKind.String)
+        {
+            var valueStr = value.GetString()!;
+            var inputStr = inputElement.GetString()!;
+
+            if (Guid.TryParse(valueStr, out var valueGuid) && Guid.TryParse(inputStr, out var inputGuid))
+            {
+                return valueGuid == inputGuid;
+            }
+        }
+
+        switch (value.ValueKind)
+        {
+            case JsonValueKind.Object:
+                {
+                    if (inputElement.ValueKind != JsonValueKind.Object)
+                    {
+                        return false;
+                    }
+
+                    var valueProperties = value.EnumerateObject().ToDictionary(p => p.Name, p => p.Value);
+                    var inputProperties = inputElement.EnumerateObject().ToDictionary(p => p.Name, p => p.Value);
+
+                    if (valueProperties.Count != inputProperties.Count)
+                    {
+                        return false;
+                    }
+
+                    foreach (var pair in valueProperties)
+                    {
+                        if (!inputProperties.TryGetValue(pair.Key, out var inputPropValue))
+                        {
+                            return false;
+                        }
+
+                        if (!IsMatch(pair.Value, inputPropValue))
+                        {
+                            return false;
+                        }
+                    }
+
+                    return true;
+                }
+
+            case JsonValueKind.Array:
+                {
+                    if (inputElement.ValueKind != JsonValueKind.Array)
+                    {
+                        return false;
+                    }
+
+                    var valueArray = value.EnumerateArray().ToArray();
+                    var inputArray = inputElement.EnumerateArray().ToArray();
+
+                    if (valueArray.Length != inputArray.Length)
+                    {
+                        return false;
+                    }
+
+                    return !valueArray.Where((valueToken, index) => !IsMatch(valueToken, inputArray[index])).Any();
+                }
+
+            default:
+                return value.GetRawText() == inputElement.GetRawText();
+        }
+    }
+
+    private JsonElement NormalizeElement(JsonElement element)
+    {
+        if (!IgnoreCase)
+        {
+            return element;
+        }
+
+        var normalized = NormalizeValue(element);
+        return ConvertToJsonElement(normalized);
+    }
+
+    private object NormalizeValue(JsonElement element)
+    {
+        switch (element.ValueKind)
+        {
+            case JsonValueKind.Object:
+                {
+                    var dict = new Dictionary<string, object?>();
+                    foreach (var prop in element.EnumerateObject())
+                    {
+                        var normalizedKey = prop.Name.ToUpperInvariant();
+                        dict[normalizedKey] = NormalizeValue(prop.Value);
+                    }
+
+                    return dict;
+                }
+
+            case JsonValueKind.Array:
+                {
+                    if (Regex)
+                    {
+                        return element.EnumerateArray().Select(e => (object)e.GetRawText()).ToArray();
+                    }
+
+                    return element.EnumerateArray().Select(NormalizeValue).ToArray();
+                }
+
+            case JsonValueKind.String:
+                {
+                    var str = element.GetString()!;
+                    return Regex ? str : str.ToUpperInvariant();
+                }
+
+            default:
+                return element.GetRawText();
+        }
+    }
+
+    private static JsonElement ConvertToJsonElement(object value)
+    {
+        switch (value)
+        {
+            case JsonElement jsonElement:
+                return jsonElement;
+
+            case JsonDocument jsonDocument:
+                return jsonDocument.RootElement;
+
+            case string stringValue:
+                return JsonDocument.Parse(stringValue).RootElement;
+
+            case IEnumerable enumerableValue when value is not string:
+                return JsonSerializer.SerializeToElement(enumerableValue, DefaultSerializerOptions);
+
+            default:
+                var json = JsonSerializer.Serialize(value, DefaultSerializerOptions);
+                return JsonDocument.Parse(json).RootElement;
+        }
+    }
+}
@@ -0,0 +1,52 @@
+// Copyright © WireMock.Net
+
+using WireMock.Extensions;
+using WireMock.Util;
+
+namespace WireMock.Matchers;
+
+/// <summary>
+/// SystemTextJsonPartialMatcher - uses System.Text.Json instead of Newtonsoft.Json.
+/// </summary>
+public class SystemTextJsonPartialMatcher : AbstractSystemTextJsonPartialMatcher
+{
+    /// <inheritdoc />
+    public override string Name => nameof(SystemTextJsonPartialMatcher);
+
+    /// <inheritdoc />
+    public SystemTextJsonPartialMatcher(string value, bool ignoreCase = false, bool regex = false)
+        : base(value, ignoreCase, regex)
+    {
+    }
+
+    /// <inheritdoc />
+    public SystemTextJsonPartialMatcher(object value, bool ignoreCase = false, bool regex = false)
+        : base(value, ignoreCase, regex)
+    {
+    }
+
+    /// <inheritdoc />
+    public SystemTextJsonPartialMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false, bool regex = false)
+        : base(matchBehaviour, value, ignoreCase, regex)
+    {
+    }
+
+    /// <inheritdoc />
+    protected override bool IsMatch(string value, string input)
+    {
+        var exactStringMatcher = new ExactMatcher(MatchBehaviour.AcceptOnMatch, IgnoreCase, MatchOperator.Or, value);
+        return exactStringMatcher.IsMatch(input).IsPerfect();
+    }
+
+    /// <inheritdoc />
+    public override string GetCSharpCodeArguments()
+    {
+        return $"new {Name}" +
+               $"(" +
+               $"{MatchBehaviour.GetFullyQualifiedEnumValue()}, " +
+               $"{CSharpFormatter.ConvertToAnonymousObjectDefinition(Value, 3)}, " +
+               $"{CSharpFormatter.ToCSharpBooleanLiteral(IgnoreCase)}, " +
+               $"{CSharpFormatter.ToCSharpBooleanLiteral(Regex)}" +
+               $")";
+    }
+}
@@ -0,0 +1,52 @@
+// Copyright © WireMock.Net
+
+using WireMock.Extensions;
+using WireMock.Util;
+
+namespace WireMock.Matchers;
+
+/// <summary>
+/// SystemTextJsonPartialWildcardMatcher - uses System.Text.Json instead of Newtonsoft.Json.
+/// </summary>
+public class SystemTextJsonPartialWildcardMatcher : AbstractSystemTextJsonPartialMatcher
+{
+    /// <inheritdoc />
+    public override string Name => nameof(SystemTextJsonPartialWildcardMatcher);
+
+    /// <inheritdoc />
+    public SystemTextJsonPartialWildcardMatcher(string value, bool ignoreCase = false, bool regex = false)
+        : base(value, ignoreCase, regex)
+    {
+    }
+
+    /// <inheritdoc />
+    public SystemTextJsonPartialWildcardMatcher(object value, bool ignoreCase = false, bool regex = false)
+        : base(value, ignoreCase, regex)
+    {
+    }
+
+    /// <inheritdoc />
+    public SystemTextJsonPartialWildcardMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false, bool regex = false)
+        : base(matchBehaviour, value, ignoreCase, regex)
+    {
+    }
+
+    /// <inheritdoc />
+    protected override bool IsMatch(string value, string input)
+    {
+        var wildcardStringMatcher = new WildcardMatcher(MatchBehaviour.AcceptOnMatch, value, IgnoreCase);
+        return wildcardStringMatcher.IsMatch(input).IsPerfect();
+    }
+
+    /// <inheritdoc />
+    public override string GetCSharpCodeArguments()
+    {
+        return $"new {Name}" +
+               $"(" +
+               $"{MatchBehaviour.GetFullyQualifiedEnumValue()}, " +
+               $"{CSharpFormatter.ConvertToAnonymousObjectDefinition(Value, 3)}, " +
+               $"{CSharpFormatter.ToCSharpBooleanLiteral(IgnoreCase)}, " +
+               $"{CSharpFormatter.ToCSharpBooleanLiteral(Regex)}" +
+               $")";
+    }
+}