Include the differences when using WithBodyEquivalentTo

Author: dennisdoomen

Mockly.ApiVerificationTests/ApprovedApi/net472.verified.txt

@@ -15,6 +15,7 @@ namespace Mockly
         public string Query { get; }
         public System.Net.Http.HttpResponseMessage Response { get; }
         public string Scheme { get; }
+        public int Sequence { get; set; }
         public System.DateTime Timestamp { get; }
         public System.Uri? Uri { get; }
         public System.Version Version { get; }

Mockly.ApiVerificationTests/ApprovedApi/net8.0.verified.txt

@@ -16,6 +16,7 @@ namespace Mockly
         public string Query { get; }
         public System.Net.Http.HttpResponseMessage Response { get; }
         public string Scheme { get; }
+        public int Sequence { get; set; }
         public System.DateTime Timestamp { get; }
         public System.Uri? Uri { get; }
         public System.Version Version { get; }

Mockly.Specs/AssertionSpecs.cs

@@ -481,7 +481,12 @@ public async Task Fails_when_body_is_not_equivalent_to_anonymous_object()
                 .WithBodyEquivalentTo(expected);
 
             // Assert
-            act.Should().Throw<XunitException>();
+            act.Should().Throw<XunitException>().WithMessage(
+                """
+                Expected request #1 (POST https://localhost/api/test) to have a body equivalent to the expectation, but it did not:
+                - Expected property actual.id to be 2, but found 1.
+                - Expected property actual.name to be "y", but "x" differs near "x" (index 0).*
+                """);
         }
     }
 
@@ -500,17 +505,19 @@ public async Task Matches_body_having_properties_of_dictionary()
             await client.PostAsync("https://localhost/api/test", new StringContent("{ \"id\":\"1\", \"name\":\"x\" }"));
 
             // Assert
-            mock.Requests.Should().ContainRequest().WithBodyHavingPropertiesOf(new Dictionary<string, string>(StringComparer.Ordinal)
-            {
-                ["id"] = "1",
-                ["name"] = "x"
-            });
+            mock.Requests.Should().ContainRequest().WithBodyHavingPropertiesOf(
+                new Dictionary<string, string>(StringComparer.Ordinal)
+                {
+                    ["id"] = "1",
+                    ["name"] = "x"
+                });
 
-            mock.Requests.Should().ContainRequest().WithBodyHavingPropertiesOf(new Dictionary<string, string>(StringComparer.Ordinal)
-            {
-                ["id"] = "2",
-                ["name"] = "y"
-            });
+            mock.Requests.Should().ContainRequest().WithBodyHavingPropertiesOf(
+                new Dictionary<string, string>(StringComparer.Ordinal)
+                {
+                    ["id"] = "2",
+                    ["name"] = "y"
+                });
         }
 
         [Fact]

Mockly/CapturedRequest.cs

@@ -107,11 +107,14 @@ public Version Version
         get => request.Version;
     }
 
+    /// <summary>
+    /// The sequence number of the captured request, starting at 1.
+    /// </summary>
+    public int Sequence { get; set; }
+
     public override string ToString()
     {
-        string route = $"{Method} {Scheme}://{Host}{Path}{Query}";
-
-        return route;
+        return $"{Method} {Scheme}://{Host}{Path}{Query}";
     }
 
 }

Mockly/RequestCollection.cs

@@ -18,6 +18,7 @@ public class RequestCollection : IEnumerable<CapturedRequest>
     internal void Add(CapturedRequest request)
     {
         requests.Add(request);
+        request.Sequence = requests.Count;
     }
 
     /// <summary>

Shared/HttpMockAssertionExtensions.cs

@@ -492,7 +492,8 @@ public AndWhichConstraint<ContainedRequestAssertions, CapturedRequest> WithBodyE
         string because = "",
         params object[] becauseArgs)
     {
-        string[] failures = [];
+        string[] leastFailures = [];
+        CapturedRequest? bestMatch = null;
         foreach (CapturedRequest request in requests)
         {
             T? actual = request.Body is null ? default : JsonSerializer.Deserialize<T>(request.Body!);
@@ -501,36 +502,42 @@ public AndWhichConstraint<ContainedRequestAssertions, CapturedRequest> WithBodyE
                 using var scope = new AssertionScope();
                 actual.Should().BeEquivalentTo(expected, because, becauseArgs);
 
-                failures = scope.Discard();
+                var failures = scope.Discard();
                 if (failures.Length == 0)
                 {
                     return new AndWhichConstraint<ContainedRequestAssertions, CapturedRequest>(this, request);
                 }
+
+                if (leastFailures.Length == 0 || failures.Length < leastFailures.Length)
+                {
+                    leastFailures = failures;
+                    bestMatch = request;
+                }
             }
         }
 
+        string message;
         if (requests.Length == 1)
         {
-#if FA8
-            AssertionChain.GetOrCreate()
-#else
-            Execute.Assertion
-#endif
-                .BecauseOf(because, becauseArgs)
-                .FailWith(
-                    "Expected the request body to be equivalent to the expectation{because}, but it failed with: {0}",
-                    string.Join(Environment.NewLine, failures));
+            message = "Expected request #{0} ({1}) to have a body equivalent to the expectation{because}, but it did not:";
         }
         else
         {
+            message =
+                "Expected the closest matching request #{0} ({1}) at have a body equivalent to the expectation{because}, but it did not:";
+        }
+
 #if FA8
-            AssertionChain.GetOrCreate()
+        AssertionChain.GetOrCreate()
 #else
-            Execute.Assertion
+        Execute.Assertion
 #endif
-                .BecauseOf(because, becauseArgs)
-                .FailWith("Expected at least one request body to be equivalent to the expected object{because}, but none were");
-        }
+            .BecauseOf(because, becauseArgs)
+            .FailWith(message +
+                      Environment.NewLine +
+                      string.Join(Environment.NewLine, leastFailures.Select(failure => $"- {failure}")) +
+                      Environment.NewLine,
+                bestMatch!.Sequence, bestMatch);
 
         return new AndWhichConstraint<ContainedRequestAssertions, CapturedRequest>(this, []);
     }
@@ -582,15 +589,16 @@ public AndWhichConstraint<ContainedRequestAssertions, CapturedRequest> WithBodyH
             Execute.Assertion
 #endif
                 .BecauseOf(because, becauseArgs)
-                .FailWith("Expected the top-level properties of the request body to be equivalent to the provided dictionary{because}, but it failed with: ",
+                .FailWith(
+                    "Expected the top-level properties of the request body to be equivalent to the provided dictionary{because}, but it failed with: ",
                     string.Join(Environment.NewLine, failures));
         }
         else
         {
 #if FA8
             AssertionChain.GetOrCreate()
 #else
-        Execute.Assertion
+            Execute.Assertion
 #endif
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected at least one request body to have the expected properties{because}, but none did");
@@ -645,18 +653,20 @@ public AndWhichConstraint<ContainedRequestAssertions, CapturedRequest> WithBodyH
             Execute.Assertion
 #endif
                 .BecauseOf(because, becauseArgs)
-                .FailWith("Expected the request body to contain property {0} with value {1}{because}, but it did not: {2}", key, value,
+                .FailWith("Expected the request body to contain property {0} with value {1}{because}, but it did not: {2}", key,
+                    value,
                     string.Join(Environment.NewLine, failures));
         }
         else
         {
 #if FA8
             AssertionChain.GetOrCreate()
 #else
-        Execute.Assertion
+            Execute.Assertion
 #endif
                 .BecauseOf(because, becauseArgs)
-                .FailWith("Expected at least one request body to contain property {0} with value {1}{because}, but none did", key, value);
+                .FailWith("Expected at least one request body to contain property {0} with value {1}{because}, but none did", key,
+                    value);
         }
 
         return new AndWhichConstraint<ContainedRequestAssertions, CapturedRequest>(this, []);