v1.6.0

- Improves the BeJsonSerializableInto() and BeJsonDeserializableInto() methods to use C# raw string literal.

Author: GillesTourreau

.github/workflows/github-actions-release.yml

@@ -7,7 +7,7 @@ on:
         type: string
         description: The version of the library
         required: true
-        default: 1.5.0
+        default: 1.6.0
       VersionSuffix:
         type: string
         description: The version suffix of the library (for example rc.1)

README.md

@@ -116,6 +116,31 @@ public void Serialization()
 And when an exception is occured, the exception message contains the JSON path of the property which is error:
 ![Pretty exception](https://raw.githubusercontent.com/PosInformatique/PosInformatique.FluentAssertions.Json/main/docs/PrettyExceptionSample.png)
 
+Since the version 1.6.0 it is possible to use a [raw string literal](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/raw-string)
+with a JSON content in the string:
+
+```csharp
+[Fact]
+public void Serialization()
+{
+    var customer = new Customer()
+    {
+        Id = 1234,
+        Name = "Gilles TOURREAU",
+        Gender = Gender.Male,
+    };
+
+    customer.Should().BeJsonSerializableInto(
+    """
+    {
+        "id": 1234,
+        "name": "Gilles TOURREAU",
+        "gender": 100
+    }
+    """);
+}
+```
+
 ### Test the deserialization of a JSON object to a .NET Object
 You can in the same way test the deserialization JSON object into a .NET object.
 
@@ -139,7 +164,32 @@ public void Deserialization()
 }
 ```
 
-## Test polymorphisme serialization with property discriminator
+Since the version 1.6.0 it is possible to use a [raw string literal](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/raw-string)
+with a JSON string content as input of the `Should()` to assert:
+
+```
+[Fact]
+public void Deserialization()
+{
+    var json =
+    """
+    {
+        "id": 1234,
+        "name": "Gilles TOURREAU",
+        "gender": 100
+    }
+    """;
+
+    json.Should().BeJsonDeserializableInto(new Customer()
+    {
+        Id = 1234,
+        Name = "Gilles TOURREAU",
+        Gender = Gender.Male,
+    });
+}
+```
+
+## Test polymorphism serialization with property discriminator
 With the .NET 7.0 version of the `System.Text.Json` it is possible to serialize and deserialize JSON object
 with property discriminators for polymorphism scenario
 (See the [How to serialize properties of derived classes with System.Text.Json](https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/polymorphism?pivots=dotnet-7-0))

src/FluentAssertions.Json/JsonElementComparer.cs

@@ -12,27 +12,168 @@ namespace PosInformatique.FluentAssertions.Json
 
     internal static class JsonElementComparer
     {
-        public static IReadOnlyList<string> Compare(JsonDocument document, object? expected)
+        public static IReadOnlyList<string> CompareWithDocument(JsonDocument document, JsonDocument expected)
         {
-            return Compare(document.RootElement, expected, "$");
+            return CompareWithElement(document.RootElement, expected.RootElement, "$");
         }
 
-        public static IReadOnlyList<string> Compare(JsonElement element, object? expected, string initialPath)
+        public static IReadOnlyList<string> CompareWithElement(JsonElement element, JsonElement expected, string initialPath)
         {
             var errors = new List<string>();
 
             var path = new Stack<string>();
 
             path.Push(initialPath);
 
-            Compare(element, expected, path, errors);
+            CompareWithElement(element, expected, path, errors);
 
             path.Pop();
 
             return errors;
         }
 
-        private static void Compare(JsonElement element, object? expected, Stack<string> path, List<string> errors)
+        public static IReadOnlyList<string> CompareWithObject(JsonDocument document, object? expected)
+        {
+            return CompareWithObject(document.RootElement, expected, "$");
+        }
+
+        public static IReadOnlyList<string> CompareWithObject(JsonElement element, object? expected, string initialPath)
+        {
+            var errors = new List<string>();
+
+            var path = new Stack<string>();
+
+            path.Push(initialPath);
+
+            CompareWithObject(element, expected, path, errors);
+
+            path.Pop();
+
+            return errors;
+        }
+
+        private static void CompareWithElement(JsonElement element, JsonElement expected, Stack<string> path, List<string> errors)
+        {
+            if (element.ValueKind != expected.ValueKind)
+            {
+                errors.Add($"{GetPath(path)}: Expected property to be '{expected.ValueKind}' type instead of '{element.ValueKind}' type.");
+                return;
+            }
+
+            if (element.ValueKind == JsonValueKind.String)
+            {
+                var value = element.GetString();
+                var expectedStringValue = expected.GetString();
+
+                if (value != expectedStringValue)
+                {
+                    errors.Add($"{GetPath(path)}: Expected '{expected}' instead of '{value}'.");
+                    return;
+                }
+            }
+            else if (element.ValueKind == JsonValueKind.Number)
+            {
+                var value = element.GetDouble();
+                var expectedDoubleValue = expected.GetDouble();
+
+                if (value != expectedDoubleValue)
+                {
+                    errors.Add($"{GetPath(path)}: Expected '{expected}' instead of '{value}'.");
+                    return;
+                }
+            }
+            else if (element.ValueKind == JsonValueKind.Object)
+            {
+                var expectedPropertyEnumerator = expected.EnumerateObject();
+
+                foreach (var property in element.EnumerateObject())
+                {
+                    if (!expectedPropertyEnumerator.MoveNext())
+                    {
+                        errors.Add($"{GetPath(path)}: Expected no property but found '{property.Name}' property.");
+                        continue;
+                    }
+
+                    var expectedProperty = expectedPropertyEnumerator.Current;
+
+                    if (property.Name != expectedProperty.Name)
+                    {
+                        errors.Add($"{GetPath(path)}: Expected property with the '{expectedProperty.Name}' name but found '{property.Name}' instead.");
+                        continue;
+                    }
+
+                    path.Push("." + property.Name);
+
+                    var expectedValueOfProperty = expectedProperty.Value;
+
+                    CompareWithElement(property.Value, expectedValueOfProperty, path, errors);
+
+                    path.Pop();
+                }
+
+                if (expectedPropertyEnumerator.MoveNext())
+                {
+                    errors.Add($"{GetPath(path)}: Expected '{expectedPropertyEnumerator.Current.Name}' property but found no property.");
+                    return;
+                }
+            }
+            else if (element.ValueKind == JsonValueKind.Array)
+            {
+                var expectedArrayEnumerator = expected.EnumerateArray();
+                var index = 0;
+
+                foreach (var item in element.EnumerateArray())
+                {
+                    if (!expectedArrayEnumerator.MoveNext())
+                    {
+                        var actualCount = element.EnumerateArray().Count();
+
+                        errors.Add($"{GetPath(path)}: Expected {index} item(s) but found {actualCount}.");
+                        continue;
+                    }
+
+                    var expectedItem = expectedArrayEnumerator.Current;
+
+                    path.Push($"[{index}]");
+
+                    CompareWithElement(item, expectedItem, path, errors);
+
+                    path.Pop();
+
+                    index++;
+                }
+
+                if (expectedArrayEnumerator.MoveNext())
+                {
+                    var expectedCount = expected.GetArrayLength();
+
+                    errors.Add($"{GetPath(path)}: Expected {expectedCount} item(s) but found {index}.");
+                    return;
+                }
+            }
+            else if (element.ValueKind == JsonValueKind.True)
+            {
+                var expectedBooleanValue = expected.GetBoolean();
+
+                if (expectedBooleanValue != true)
+                {
+                    errors.Add($"{GetPath(path)}: Expected '{expectedBooleanValue}' instead of '{true}'.");
+                    return;
+                }
+            }
+            else if (element.ValueKind == JsonValueKind.False)
+            {
+                var expectedBooleanValue = expected.GetBoolean();
+
+                if (expectedBooleanValue != false)
+                {
+                    errors.Add($"{GetPath(path)}: Expected '{expectedBooleanValue}' instead of '{false}'.");
+                    return;
+                }
+            }
+        }
+
+        private static void CompareWithObject(JsonElement element, object? expected, Stack<string> path, List<string> errors)
         {
             if (element.ValueKind == JsonValueKind.String)
             {
@@ -98,7 +239,7 @@ private static void Compare(JsonElement element, object? expected, Stack<string>
 
                     var expectedValueOfProperty = expectedProperty.GetValue(expected);
 
-                    Compare(property.Value, expectedValueOfProperty, path, errors);
+                    CompareWithObject(property.Value, expectedValueOfProperty, path, errors);
 
                     path.Pop();
                 }
@@ -134,7 +275,7 @@ private static void Compare(JsonElement element, object? expected, Stack<string>
 
                     path.Push($"[{index}]");
 
-                    Compare(item, expectedItem, path, errors);
+                    CompareWithObject(item, expectedItem, path, errors);
 
                     path.Pop();