add ContainSubtree that takes a config

Author: sam.segers

Src/FluentAssertions.Json/JTokenAssertions.cs

@@ -431,6 +431,49 @@ public AndConstraint<JTokenAssertions> ContainSubtree(string subtree, string bec
         return ContainSubtree(subtreeToken, because, becauseArgs);
     }
 
+    /// <summary>
+    ///     Recursively asserts that the current <see cref="JToken"/> contains at least the properties or elements of the specified <paramref name="subtree"/>.
+    /// </summary>
+    /// <param name="subtree">The subtree to search for</param>
+    /// <param name="config">The options to consider while asserting values</param>
+    /// <param name="because">
+    /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+    /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+    /// </param>
+    /// <param name="becauseArgs">
+    /// Zero or more objects to format using the placeholders in <paramref name="because"/>.
+    /// </param>
+    /// <remarks>Use this method to match the current <see cref="JToken"/> against an arbitrary subtree,
+    /// permitting it to contain any additional properties or elements. This way we can test multiple properties on a <see cref="JObject"/> at once,
+    /// or test if a <see cref="JArray"/> contains any items that match a set of properties, assert that a JSON document has a given shape, etc. </remarks>
+    /// <example>
+    /// This example asserts the values of multiple properties of a child object within a JSON document using a specified double precision.
+    /// <code>
+    /// var json = JToken.Parse("{ success: true, data: { id: 123, type: 'my-type', value: 0.99 } }");
+    /// json.Should().ContainSubtree(JToken.Parse("{ success: true, data: { type: 'my-type', value: 1.0 } }"), options => options
+    ///     .Using&lt;double&gt;(d => d.Subject.Should().BeApproximately(d.Expectation, 1e-1))
+    ///     .WhenTypeIs&lt;double&gt;());
+    /// </code>
+    /// </example>
+    /// <example>
+    /// This example asserts that a <see cref="JArray"/> within a <see cref="JObject"/> has at least one element with at least the given properties, using a specified double precision.
+    /// <code>
+    /// var json = JToken.Parse("{ id: 1, items: [ { id: 2, type: 'my-type', value: 0.99 }, { id: 3, type: 'other-type', value: 3 } ] }");
+    /// json.Should().ContainSubtree("{ items: [ { type: 'my-type', value: 1 } ] }", options => options
+    ///     .Using&lt;double&gt;(d => d.Subject.Should().BeApproximately(d.Expectation, 1e-1))
+    ///     .WhenTypeIs&lt;double&gt;());
+    /// </code>
+    /// </example>
+    public AndConstraint<JTokenAssertions> ContainSubtree(string subtree,
+        Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config,
+        string because = "",
+        params object[] becauseArgs)
+    {
+        JToken subtreeToken = Parse(subtree, nameof(subtree));
+
+        return BeEquivalentTo(subtreeToken, true, config, because, becauseArgs);
+    }
+
     /// <summary>
     /// Recursively asserts that the current <see cref="JToken"/> contains at least the properties or elements of the specified <paramref name="subtree"/>.
     /// </summary>
@@ -464,6 +507,47 @@ public AndConstraint<JTokenAssertions> ContainSubtree(JToken subtree, string bec
         return BeEquivalentTo(subtree, true, options => options, because, becauseArgs);
     }
 
+    /// <summary>
+    ///     Recursively asserts that the current <see cref="JToken"/> contains at least the properties or elements of the specified <paramref name="subtree"/>.
+    /// </summary>
+    /// <param name="subtree">The subtree to search for</param>
+    /// <param name="config">The options to consider while asserting values</param>
+    /// <param name="because">
+    /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+    /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+    /// </param>
+    /// <param name="becauseArgs">
+    /// Zero or more objects to format using the placeholders in <paramref name="because"/>.
+    /// </param>
+    /// <remarks>Use this method to match the current <see cref="JToken"/> against an arbitrary subtree,
+    /// permitting it to contain any additional properties or elements. This way we can test multiple properties on a <see cref="JObject"/> at once,
+    /// or test if a <see cref="JArray"/> contains any items that match a set of properties, assert that a JSON document has a given shape, etc. </remarks>
+    /// <example>
+    /// This example asserts the values of multiple properties of a child object within a JSON document, using a specified double precision.
+    /// <code>
+    /// var json = JToken.Parse("{ success: true, data: { id: 123, type: 'my-type', value: 0.99 } }");
+    /// json.Should().ContainSubtree(JToken.Parse("{ success: true, data: { type: 'my-type', value: 1.0 } }"), options => options
+    ///     .Using&lt;double&gt;(d => d.Subject.Should().BeApproximately(d.Expectation, 1e-1))
+    ///     .WhenTypeIs&lt;double&gt;());
+    /// </code>
+    /// </example>
+    /// <example>
+    /// This example asserts that a <see cref="JArray"/> within a <see cref="JObject"/> has at least one element with at least the given properties, using a specified double precision.
+    /// <code>
+    /// var json = JToken.Parse("{ id: 1, items: [ { id: 2, type: 'my-type', value: 0.99 }, { id: 3, type: 'other-type', value: 3 } ] }");
+    /// json.Should().ContainSubtree(JToken.Parse("{ items: [ { type: 'my-type', value: 1 } ] }"), options => options
+    ///     .Using&lt;double&gt;(d => d.Subject.Should().BeApproximately(d.Expectation, 1e-1))
+    ///     .WhenTypeIs&lt;double&gt;());
+    /// </code>
+    /// </example>
+    public AndConstraint<JTokenAssertions> ContainSubtree(JToken subtree,
+        Func<IJsonAssertionOptions<object>, IJsonAssertionOptions<object>> config,
+        string because = "",
+        params object[] becauseArgs)
+    {
+        return BeEquivalentTo(subtree, true, config, because, becauseArgs);
+    }
+
     private static JToken Parse(string json, string paramName)
     {
         try

Tests/FluentAssertions.Json.Specs/JTokenAssertionsSpecs.cs

@@ -947,6 +947,35 @@ public void When_checking_subtree_with_an_invalid_expected_string_it_should_prov
             .WithInnerException<JsonReaderException>();
     }
 
+    [Fact]
+    public void Assert_property_with_approximation_succeeds()
+    {
+        // Arrange
+        var actual = JToken.Parse("{ \"id\": 1.1232 }");
+        var expected = JToken.Parse("{ \"id\": 1.1235 }");
+
+        // Act & Assert
+        actual.Should().ContainSubtree(expected, options => options
+            .Using<double>(d => d.Subject.Should().BeApproximately(d.Expectation, 1e-3))
+            .WhenTypeIs<double>());
+    }
+
+    [Fact]
+    public void Can_assert_on_a_field_with_approximation()
+    {
+        // Arrange
+        var actual = JToken.Parse("{ \"id\": 1.1232 }");
+        var expected = JToken.Parse("{ \"id\": 1.1235 }");
+
+        // Act & Assert
+        actual.Should().
+            Invoking(x => x.ContainSubtree(expected, options => options
+                .Using<double>(d => d.Subject.Should().BeApproximately(d.Expectation, 1e-5))
+                .WhenTypeIs<double>()))
+            .Should().Throw<XunitException>()
+            .WithMessage("JSON document has a different value at $.id.*");
+    }
+
     #endregion
 
     private static string Format(JToken value, bool useLineBreaks = false)