Improve error messages for ContainSubtree (#36)

* Improve error messages for ContainSubtree
* Also require strict order for elements in an array when checking subtree

Author: ronaldkroon

Src/FluentAssertions.Json/JTokenAssertions.cs

@@ -1,5 +1,4 @@
 using System.Diagnostics;
-using System.Linq;
 using FluentAssertions.Collections;
 using FluentAssertions.Json.Common;
 using FluentAssertions.Execution;
@@ -86,12 +85,20 @@ public AndConstraint<JTokenAssertions> BeEquivalentTo(string expected, string be
         public AndConstraint<JTokenAssertions> BeEquivalentTo(JToken expected, string because = "",
             params object[] becauseArgs)
         {
-            Difference difference = JTokenDifferentiator.FindFirstDifference(Subject, expected);
+            return BeEquivalentTo(expected, false, because, becauseArgs);
+        }
+
+        private AndConstraint<JTokenAssertions> BeEquivalentTo(JToken expected, bool ignoreExtraProperties, string because = "",
+            params object[] becauseArgs)
+        {
+            Difference difference = JTokenDifferentiator.FindFirstDifference(Subject, expected, ignoreExtraProperties);
+
+            var expectation = ignoreExtraProperties ? "was expected to contain" : "was expected to be equivalent to";
 
             var message = $"JSON document {difference?.ToString().EscapePlaceholders()}.{Environment.NewLine}" +
                           $"Actual document{Environment.NewLine}" +
                           $"{Format(Subject, true).EscapePlaceholders()}{Environment.NewLine}" +
-                          $"was expected to be equivalent to{Environment.NewLine}" +
+                          $"{expectation}{Environment.NewLine}" +
                           $"{Format(expected, true).EscapePlaceholders()}{Environment.NewLine}" +
                           "{reason}.";
 
@@ -373,9 +380,9 @@ public AndConstraint<JTokenAssertions> HaveCount(int expected, string because =
                 return new AndConstraint<JTokenAssertions>(this);
             }
         }
-        
+
         /// <summary>
-        /// Recursively asserts that the current <see cref="JToken"/> contains at least the properties or elements of the specified <see cref="JToken"/>.
+        /// Recursively asserts that the current <see cref="JToken"/> contains at least the properties or elements of the specified <paramref name="substree"/>.
         /// </summary>
         /// <param name="subtree">The subtree to search for</param>
         /// <param name="because">
@@ -400,18 +407,27 @@ public AndConstraint<JTokenAssertions> HaveCount(int expected, string because =
         /// var json = JToken.Parse("{ id: 1, items: [ { id: 2, type: 'my-type', name: 'Alpha' }, { id: 3, type: 'other-type', name: 'Bravo' } ] }");
         /// json.Should().ContainSubtree(JToken.Parse("{ items: [ { type: 'my-type', name: 'Alpha' } ] }"));
         /// </code>
-        public AndConstraint<JTokenAssertions> ContainSubtree(JToken subtree, string because = "", params object[] becauseArgs)
+        public AndConstraint<JTokenAssertions> ContainSubtree(string subtree, string because = "", params object[] becauseArgs)
         {
-            Execute.Assertion
-                .ForCondition(JTokenContainsSubtree(Subject, subtree))
-                .BecauseOf(because, becauseArgs)
-                .FailWith("Expected JSON document to contain subtree {0} {reason}, but some elements were missing.", subtree); // todo: report exact cause of failure, eg. name of the missing property, etc.
+            JToken subtreeToken;
+            try
+            {
+                subtreeToken = JToken.Parse(subtree);
+            }
+            catch (Exception ex)
+            {
+                throw new ArgumentException(
+                    $"Unable to parse expected JSON string:{Environment.NewLine}" +
+                    $"{subtree}{Environment.NewLine}" +
+                    "Check inner exception for more details.",
+                    nameof(subtree), ex);
+            }
 
-            return new AndConstraint<JTokenAssertions>(this);
+            return ContainSubtree(subtreeToken, because, becauseArgs);
         }
 
         /// <summary>
-        /// Recursively asserts that the current <see cref="JToken"/> contains at least the properties or elements of the specified <see cref="JToken"/>.
+        /// Recursively asserts that the current <see cref="JToken"/> contains at least the properties or elements of the specified <paramref name="substree"/>.
         /// </summary>
         /// <param name="subtree">The subtree to search for</param>
         /// <param name="because">
@@ -436,62 +452,9 @@ public AndConstraint<JTokenAssertions> ContainSubtree(JToken subtree, string bec
         /// var json = JToken.Parse("{ id: 1, items: [ { id: 2, type: 'my-type', name: 'Alpha' }, { id: 3, type: 'other-type', name: 'Bravo' } ] }");
         /// json.Should().ContainSubtree(JToken.Parse("{ items: [ { type: 'my-type', name: 'Alpha' } ] }"));
         /// </code>
-        public AndConstraint<JTokenAssertions> ContainSubtree(string subtree, string because = "", params object[] becauseArgs)
-        {
-            JToken subtreeToken;
-            try
-            {
-                subtreeToken = JToken.Parse(subtree);
-            }
-            catch (Exception ex)
-            {
-                throw new ArgumentException(
-                    $"Unable to parse expected JSON string:{Environment.NewLine}" +
-                    $"{subtree}{Environment.NewLine}" +
-                    "Check inner exception for more details.",
-                    nameof(subtree), ex);
-            }
-
-            return ContainSubtree(subtreeToken, because, becauseArgs);
-        }
-
-        private bool JTokenContainsSubtree(JToken token, JToken subtree)
+        public AndConstraint<JTokenAssertions> ContainSubtree(JToken subtree, string because = "", params object[] becauseArgs)
         {
-            switch (subtree.Type)
-            {
-                case JTokenType.Object:
-                {
-                    var sub = (JObject)subtree;
-                    var obj = token as JObject;
-                    if (obj == null)
-                        return false;
-                    foreach (var subProp in sub.Properties())
-                    {
-                        var prop = obj.Property(subProp.Name);
-                        if (prop == null)
-                            return false;
-                        if (!JTokenContainsSubtree(prop.Value, subProp.Value))
-                            return false;
-                    }
-                    return true;
-                }
-                case JTokenType.Array:
-                {
-                    var sub = (JArray)subtree;
-                    var arr = token as JArray;
-                    if (arr == null)
-                        return false;
-                    foreach (var subItem in sub)
-                    {
-                        if (!arr.Any(item => JTokenContainsSubtree(item, subItem)))
-                            return false;
-                    }
-                    return true;
-                }
-                default:
-                    return JToken.DeepEquals(token, subtree);
-
-            }
+            return BeEquivalentTo(subtree, true, because, becauseArgs);
         }
 
         public string Format(JToken value, bool useLineBreaks = false)

Src/FluentAssertions.Json/JTokenDifferentiator.cs

@@ -7,7 +7,7 @@ namespace FluentAssertions.Json
 {
     internal static class JTokenDifferentiator
     {
-        public static Difference FindFirstDifference(JToken actual, JToken expected)
+        public static Difference FindFirstDifference(JToken actual, JToken expected, bool ignoreExtraProperties)
         {
             var path = new JPath();
 
@@ -26,50 +26,100 @@ public static Difference FindFirstDifference(JToken actual, JToken expected)
                 return new Difference(DifferenceKind.ExpectedIsNull, path);
             }
 
-            return FindFirstDifference(actual, expected, path);
+            return FindFirstDifference(actual, expected, path, ignoreExtraProperties);
         }
 
-        private static Difference FindFirstDifference(JToken actual, JToken expected, JPath path)
+        private static Difference FindFirstDifference(JToken actual, JToken expected, JPath path, bool ignoreExtraProperties)
         {
             switch (actual)
             {
                 case JArray actualArray:
-                    return FindJArrayDifference(actualArray, expected, path);
-                case JObject actualObbject:
-                    return FindJObjectDifference(actualObbject, expected, path);
+                    return FindJArrayDifference(actualArray, expected, path, ignoreExtraProperties);
+                case JObject actualObject:
+                    return FindJObjectDifference(actualObject, expected, path, ignoreExtraProperties);
                 case JProperty actualProperty:
-                    return FindJPropertyDifference(actualProperty, expected, path);
+                    return FindJPropertyDifference(actualProperty, expected, path, ignoreExtraProperties);
                 case JValue actualValue:
                     return FindValueDifference(actualValue, expected, path);
                 default: 
                     throw new NotSupportedException();
             }
         }
 
-        private static Difference FindJArrayDifference(JArray actualArray, JToken expected, JPath path)
+        private static Difference FindJArrayDifference(JArray actualArray, JToken expected, JPath path,
+            bool ignoreExtraProperties)
         {
             if (!(expected is JArray expectedArray))
             {
                 return new Difference(DifferenceKind.OtherType, path, Describe(actualArray.Type), Describe(expected.Type));
             }
-            
-            return CompareItems(actualArray, expectedArray, path);
+
+            if (ignoreExtraProperties)
+            {
+                return CompareExpectedItems(actualArray, expectedArray, path);
+            }
+            else
+            {
+                return CompareItems(actualArray, expectedArray, path);
+            }
+        }
+
+        private static Difference CompareExpectedItems(JArray actual, JArray expected, JPath path)
+        {
+            JToken[] actualChildren = actual.Children().ToArray();
+            JToken[] expectedChildren = expected.Children().ToArray();
+
+            int matchingIndex = 0;
+            for (int expectedIndex = 0; expectedIndex < expectedChildren.Length; expectedIndex++)
+            {
+                var expectedChild = expectedChildren[expectedIndex];
+                bool match = false;
+                for (int actualIndex = matchingIndex; actualIndex < actualChildren.Length; actualIndex++)
+                {
+                    var difference = FindFirstDifference(actualChildren[actualIndex], expectedChild, true);
+
+                    if (difference == null)
+                    {
+                        match = true;
+                        matchingIndex = actualIndex + 1;
+                        break;
+                    }
+                }
+
+                if (!match)
+                {
+                    if (matchingIndex >= actualChildren.Length)
+                    {
+                        if (actualChildren.Any(actualChild => FindFirstDifference(actualChild, expectedChild, true) == null))
+                        {
+                            return new Difference(DifferenceKind.WrongOrder, path.AddIndex(expectedIndex));
+                        }
+
+                        return new Difference(DifferenceKind.ActualMissesElement, path.AddIndex(expectedIndex));
+                    }
+
+                    return FindFirstDifference(actualChildren[matchingIndex], expectedChild,
+                        path.AddIndex(expectedIndex), true);
+                }
+            }
+
+            return null;
         }
 
         private static Difference CompareItems(JArray actual, JArray expected, JPath path)
         {
-            JEnumerable<JToken> actualChildren = actual.Children();
-            JEnumerable<JToken> expectedChildren = expected.Children();
+            JToken[] actualChildren = actual.Children().ToArray();
+            JToken[] expectedChildren = expected.Children().ToArray();
 
-            if (actualChildren.Count() != expectedChildren.Count())
+            if (actualChildren.Length != expectedChildren.Length)
             {
-                return new Difference(DifferenceKind.DifferentLength, path, actualChildren.Count(), expectedChildren.Count());
+                return new Difference(DifferenceKind.DifferentLength, path, actualChildren.Length, expectedChildren.Length);
             }
 
-            for (int i = 0; i < actualChildren.Count(); i++)
+            for (int i = 0; i < actualChildren.Length; i++)
             {
-                Difference firstDifference = FindFirstDifference(actualChildren.ElementAt(i), expectedChildren.ElementAt(i), 
-                    path.AddIndex(i));
+                Difference firstDifference = FindFirstDifference(actualChildren[i], expectedChildren[i], 
+                    path.AddIndex(i), false);
 
                 if (firstDifference != null)
                 {
@@ -80,17 +130,18 @@ private static Difference CompareItems(JArray actual, JArray expected, JPath pat
             return null;
         }
 
-        private static Difference FindJObjectDifference(JObject actual, JToken expected, JPath path)
+        private static Difference FindJObjectDifference(JObject actual, JToken expected, JPath path, bool ignoreExtraProperties)
         {
             if (!(expected is JObject expectedObject))
             {
                 return new Difference(DifferenceKind.OtherType, path, Describe(actual.Type), Describe(expected.Type));
             }
 
-            return CompareProperties(actual?.Properties(), expectedObject.Properties(), path);
+            return CompareProperties(actual?.Properties(), expectedObject.Properties(), path, ignoreExtraProperties);
         }
 
-        private static Difference CompareProperties(IEnumerable<JProperty> actual, IEnumerable<JProperty> expected, JPath path)
+        private static Difference CompareProperties(IEnumerable<JProperty> actual, IEnumerable<JProperty> expected, JPath path,
+            bool ignoreExtraProperties)
         {
             var actualDictionary = actual?.ToDictionary(p => p.Name, p => p.Value) ?? new Dictionary<string, JToken>();
             var expectedDictionary = expected?.ToDictionary(p => p.Name, p => p.Value) ?? new Dictionary<string, JToken>();
@@ -105,7 +156,7 @@ private static Difference CompareProperties(IEnumerable<JProperty> actual, IEnum
 
             foreach (KeyValuePair<string, JToken> actualPair in actualDictionary)
             {
-                if (!expectedDictionary.ContainsKey(actualPair.Key))
+                if (!ignoreExtraProperties && !expectedDictionary.ContainsKey(actualPair.Key))
                 {
                     return new Difference(DifferenceKind.ExpectedMissesProperty, path.AddProperty(actualPair.Key));
                 }
@@ -116,7 +167,7 @@ private static Difference CompareProperties(IEnumerable<JProperty> actual, IEnum
                 JToken actualValue = actualDictionary[expectedPair.Key];
 
                 Difference firstDifference = FindFirstDifference(actualValue, expectedPair.Value, 
-                    path.AddProperty(expectedPair.Key));
+                    path.AddProperty(expectedPair.Key), ignoreExtraProperties);
 
                 if (firstDifference != null)
                 {
@@ -127,7 +178,8 @@ private static Difference CompareProperties(IEnumerable<JProperty> actual, IEnum
             return null;
         }
 
-        private static Difference FindJPropertyDifference(JProperty actualProperty, JToken expected, JPath path)
+        private static Difference FindJPropertyDifference(JProperty actualProperty, JToken expected, JPath path,
+            bool ignoreExtraProperties)
         {
             if (!(expected is JProperty expectedProperty))
             {
@@ -139,7 +191,7 @@ private static Difference FindJPropertyDifference(JProperty actualProperty, JTok
                 return new Difference(DifferenceKind.OtherName, path);
             }
 
-            return FindFirstDifference(actualProperty.Value, expectedProperty.Value, path);
+            return FindFirstDifference(actualProperty.Value, expectedProperty.Value, path, ignoreExtraProperties);
         }
 
         private static Difference FindValueDifference(JValue actualValue, JToken expected, JPath path)
@@ -252,6 +304,10 @@ public override string ToString()
                     return $"misses property {Path}";
                 case DifferenceKind.ExpectedMissesProperty:
                     return $"has extra property {Path}";
+                case DifferenceKind.ActualMissesElement:
+                    return $"misses expected element {Path}";
+                case DifferenceKind.WrongOrder:
+                    return $"has expected element {Path} in the wrong order";
                 default:
                     throw new ArgumentOutOfRangeException();
             }
@@ -298,6 +354,8 @@ internal enum DifferenceKind
         OtherValue,
         DifferentLength,
         ActualMissesProperty,
-        ExpectedMissesProperty
+        ExpectedMissesProperty,
+        ActualMissesElement,
+        WrongOrder
     }
 }