Allow customizing the equivalency behavior for BeXmlSerializable

Src/FluentAssertions/ObjectAssertionsExtensions.cs

@@ -28,6 +28,31 @@ public static AndConstraint<ObjectAssertions> BeDataContractSerializable(this Ob
         return BeDataContractSerializable<object>(assertions, options => options, because, becauseArgs);
     }
 
+    /// <summary>
+    /// Asserts that an object can be serialized and deserialized using the data contract serializer and that it stills retains
+    /// the values of all members.
+    /// </summary>
+    /// <param name="options">
+    /// A reference to the <see cref="EquivalencyOptions{Object}"/> configuration object that can be used
+    /// to influence the way the object graphs are compared. You can also provide an alternative instance of the
+    /// <see cref="EquivalencyOptions{Object}"/> class. The global defaults are determined by the
+    /// <see cref="AssertionConfiguration"/> class.
+    /// </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>
+    /// <exception cref="ArgumentNullException"><paramref name="options"/> is <see langword="null"/>.</exception>
+    public static AndConstraint<ObjectAssertions> BeDataContractSerializable(this ObjectAssertions assertions,
+        Func<EquivalencyOptions<object>, EquivalencyOptions<object>> options,
+        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+    {
+        return BeDataContractSerializable<object>(assertions, options, because, becauseArgs);
+    }
+
     /// <summary>
     /// Asserts that an object can be serialized and deserialized using the data contract serializer and that it stills retains
     /// the values of all members.
@@ -96,13 +121,59 @@ private static object CreateCloneUsingDataContractSerializer(object subject)
     /// </param>
     public static AndConstraint<ObjectAssertions> BeXmlSerializable(this ObjectAssertions assertions,
         [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        => BeXmlSerializable<object>(assertions, options => options, because, becauseArgs);
+
+    /// <summary>
+    /// Asserts that an object can be serialized and deserialized using the XML serializer and that it stills retains
+    /// the values of all members.
+    /// </summary>
+    /// <param name="options">
+    /// A reference to the <see cref="EquivalencyOptions{Object}"/> configuration object that can be used
+    /// to influence the way the object graphs are compared. You can also provide an alternative instance of the
+    /// <see cref="EquivalencyOptions{Object}"/> class. The global defaults are determined by the
+    /// <see cref="AssertionConfiguration"/> class.
+    /// </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>
+    public static AndConstraint<ObjectAssertions> BeXmlSerializable(this ObjectAssertions assertions,
+        Func<EquivalencyOptions<object>, EquivalencyOptions<object>> options,
+        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
+        => BeXmlSerializable<object>(assertions, options, because, becauseArgs);
+
+    /// <summary>
+    /// Asserts that an object can be serialized and deserialized using the XML serializer and that it stills retains
+    /// the values of all members.
+    /// </summary>
+    /// <param name="options">
+    /// A reference to the <see cref="EquivalencyOptions{T}"/> configuration object that can be used
+    /// to influence the way the object graphs are compared. You can also provide an alternative instance of the
+    /// <see cref="EquivalencyOptions{T}"/> class. The global defaults are determined by the
+    /// <see cref="AssertionConfiguration"/> class.
+    /// </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>
+    public static AndConstraint<ObjectAssertions> BeXmlSerializable<T>(this ObjectAssertions assertions,
+        Func<EquivalencyOptions<T>, EquivalencyOptions<T>> options,
+        [StringSyntax("CompositeFormat")] string because = "", params object[] becauseArgs)
     {
         try
         {
-            object deserializedObject = CreateCloneUsingXmlSerializer(assertions.Subject);
+            var deserializedObject = CreateCloneUsingXmlSerializer(assertions.Subject);
+
+            EquivalencyOptions<T> defaultOptions = AssertionConfiguration.Current.Equivalency.CloneDefaults<T>()
+                .PreferringRuntimeMemberTypes().IncludingFields().IncludingProperties();
 
-            deserializedObject.Should().BeEquivalentTo(assertions.Subject,
-                options => options.PreferringRuntimeMemberTypes().IncludingFields().IncludingProperties());
+            deserializedObject.Should().BeEquivalentTo((T)assertions.Subject, _ => options(defaultOptions));
         }
         catch (Exception exc)
         {

Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt

@@ -322,8 +322,11 @@ namespace FluentAssertions
     public static class ObjectAssertionsExtensions
     {
         public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { }
+        public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<object>, FluentAssertions.Equivalency.EquivalencyOptions<object>> options, string because = "", params object[] becauseArgs) { }
         public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeDataContractSerializable<T>(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<T>, FluentAssertions.Equivalency.EquivalencyOptions<T>> options, string because = "", params object[] becauseArgs) { }
         public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeXmlSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { }
+        public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeXmlSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<object>, FluentAssertions.Equivalency.EquivalencyOptions<object>> options, string because = "", params object[] becauseArgs) { }
+        public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeXmlSerializable<T>(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<T>, FluentAssertions.Equivalency.EquivalencyOptions<T>> options, string because = "", params object[] becauseArgs) { }
     }
     public abstract class OccurrenceConstraint
     {

Tests/Approval.Tests/ApprovedApi/FluentAssertions/net6.0.verified.txt

@@ -341,8 +341,11 @@ namespace FluentAssertions
     public static class ObjectAssertionsExtensions
     {
         public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { }
+        public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<object>, FluentAssertions.Equivalency.EquivalencyOptions<object>> options, string because = "", params object[] becauseArgs) { }
         public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeDataContractSerializable<T>(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<T>, FluentAssertions.Equivalency.EquivalencyOptions<T>> options, string because = "", params object[] becauseArgs) { }
         public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeXmlSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { }
+        public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeXmlSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<object>, FluentAssertions.Equivalency.EquivalencyOptions<object>> options, string because = "", params object[] becauseArgs) { }
+        public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeXmlSerializable<T>(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<T>, FluentAssertions.Equivalency.EquivalencyOptions<T>> options, string because = "", params object[] becauseArgs) { }
     }
     public abstract class OccurrenceConstraint
     {

Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt

@@ -314,8 +314,11 @@ namespace FluentAssertions
     public static class ObjectAssertionsExtensions
     {
         public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { }
+        public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<object>, FluentAssertions.Equivalency.EquivalencyOptions<object>> options, string because = "", params object[] becauseArgs) { }
         public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeDataContractSerializable<T>(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<T>, FluentAssertions.Equivalency.EquivalencyOptions<T>> options, string because = "", params object[] becauseArgs) { }
         public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeXmlSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { }
+        public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeXmlSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<object>, FluentAssertions.Equivalency.EquivalencyOptions<object>> options, string because = "", params object[] becauseArgs) { }
+        public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeXmlSerializable<T>(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<T>, FluentAssertions.Equivalency.EquivalencyOptions<T>> options, string because = "", params object[] becauseArgs) { }
     }
     public abstract class OccurrenceConstraint
     {

Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt

@@ -322,8 +322,11 @@ namespace FluentAssertions
     public static class ObjectAssertionsExtensions
     {
         public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { }
+        public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<object>, FluentAssertions.Equivalency.EquivalencyOptions<object>> options, string because = "", params object[] becauseArgs) { }
         public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeDataContractSerializable<T>(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<T>, FluentAssertions.Equivalency.EquivalencyOptions<T>> options, string because = "", params object[] becauseArgs) { }
         public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeXmlSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { }
+        public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeXmlSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<object>, FluentAssertions.Equivalency.EquivalencyOptions<object>> options, string because = "", params object[] becauseArgs) { }
+        public static FluentAssertions.AndConstraint<FluentAssertions.Primitives.ObjectAssertions> BeXmlSerializable<T>(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func<FluentAssertions.Equivalency.EquivalencyOptions<T>, FluentAssertions.Equivalency.EquivalencyOptions<T>> options, string because = "", params object[] becauseArgs) { }
     }
     public abstract class OccurrenceConstraint
     {

Tests/FluentAssertions.Specs/Primitives/ObjectAssertionSpecs.BeDataContractSerializable.cs

@@ -62,22 +62,37 @@ public void When_an_object_is_data_contract_serializable_but_doesnt_restore_all_
         }
 
         [Fact]
-        public void When_a_data_contract_serializable_object_doesnt_restore_an_ignored_property_it_should_succeed()
+        public void When_an_object_is_not_binary_serializable_and_has_ignored_properties_it_should_fail()
         {
             // Arrange
-            var subject = new DataContractSerializableClassNotRestoringAllProperties
+            var subject = new DataContractSerializableClassWithIgnoredDataMember()
             {
-                Name = "John",
-                BirthDay = 20.September(1973)
+                Name = "Deborah",
+                CachedSum = 602_214_076_000_000_000_000_000M,
             };
 
             // Act
-            Action act = () => subject.Should()
-                .BeDataContractSerializable<DataContractSerializableClassNotRestoringAllProperties>(
-                    options => options.Excluding(x => x.Name));
+            Action act = () => subject.Should().BeDataContractSerializable();
 
             // Assert
-            act.Should().NotThrow();
+            act.Should().Throw<XunitException>().WithMessage("*Expected property subject.CachedSum to be*");
+        }
+
+        [Fact]
+        public void When_an_object_is_binary_serializable_and_has_nonserialized_fields_it_should_fail()
+        {
+            // Arrange
+            var subject = new BinarySerializableClassWithNonSerializedMember()
+            {
+                Name = "Deborah",
+                CachedSum = 602_214_076_000_000_000_000_000M,
+            };
+
+            // Act
+            Action act = () => subject.Should().BeDataContractSerializable(options => options);
+
+            // Assert
+            act.Should().Throw<XunitException>().WithMessage("*Expected field subject.CachedSum to be*");
         }
 
         [Fact]
@@ -119,6 +134,26 @@ public class DataContractSerializableClassNotRestoringAllProperties
         public DateTime BirthDay { get; set; }
     }
 
+    [DataContract]
+    public class DataContractSerializableClassWithIgnoredDataMember
+    {
+        [DataMember]
+        public string Name { get; set; }
+
+        [IgnoreDataMember]
+        public decimal CachedSum { get; set; }
+    }
+
+    [Serializable]
+    public class BinarySerializableClassWithNonSerializedMember
+    {
+        // These members need to be fields for binary serialization.
+        public string Name;
+
+        [NonSerialized]
+        public decimal CachedSum;
+    }
+
     public enum Color
     {
         Red = 1,

Tests/FluentAssertions.Specs/Primitives/ObjectAssertionSpecs.BeXmlSerializable.cs

@@ -66,6 +66,23 @@ public void When_an_object_is_xml_serializable_but_doesnt_restore_all_properties
             act.Should().Throw<XunitException>()
                 .WithMessage("*to be serializable, but serialization failed with:*Name*to be*");
         }
+
+        [Fact]
+        public void When_an_object_is_xml_serializable_and_has_ignored_properties_it_should_fail()
+        {
+            // Arrange
+            var subject = new XmlSerializableClassWithIgnoredProperties()
+            {
+                Name = "Deborah",
+                CachedSum = 602_214_076_000_000_000_000_000M,
+            };
+
+            // Act
+            Action act = () => subject.Should().BeXmlSerializable();
+
+            // Assert
+            act.Should().Throw<XunitException>().WithMessage("*Expected property subject.CachedSum to be*");
+        }
     }
 
     public class XmlSerializableClass
@@ -99,6 +116,34 @@ public void WriteXml(XmlWriter writer)
         }
     }
 
+    public class XmlSerializableClassWithIgnoredProperties
+    {
+        public string Name { get; set; }
+
+        [XmlIgnore]
+        public decimal CachedSum { get; set; }
+
+        public R Splonk { get; set; } =
+            new R()
+            {
+                A = new Q() { Flarbs = "eh" },
+                B = new Q() { Flarbs = "bee" },
+            };
+    }
+
+    public class R
+    {
+        public Q A { get; set; }
+
+        public Q B { get; set; }
+    }
+
+    public class Q
+    {
+        [XmlIgnore]
+        public string Flarbs { get; set; }
+    }
+
     internal class NonPublicClass
     {
         [UsedImplicitly]

docs/_data/navigation.yml

@@ -101,6 +101,8 @@ sidebar:
         url: /tips/#improved-assertions
       - title: Migrating from MSTest
         url: /tips/#mstest-migration
+      - title: Serialization & Ignored Members
+        url: /serializationignoredmembers
 
   - title: Upgrading
     url: /upgradingtov6

docs/_pages/basicassertions.md

@@ -110,3 +110,5 @@ We’ve also added the possibility to assert that an object can be serialized an
 theObject.Should().BeXmlSerializable();
 theObject.Should().BeDataContractSerializable();
 ```
+
+See [Tips & Tricks - Serialization & Ignored Members](serializationignoredmembers.md) for additional information about the `BeXmlSerializable` and `BeDataContractSerializable` assertions and ignored members.

docs/_pages/releases.md

@@ -7,6 +7,12 @@ sidebar:
   nav: "sidebar"
 ---
 
+## Unreleased
+
+### What's new
+
+* New overloads of `BeXmlSerializable` and `BeDataContractSerializable` that allow `EquivalencyOptions` to be configured, allowing the use of member selection rules. - [#3107](https://github.com/fluentassertions/fluentassertions/pull/3107)
+
 ## 8.8.0
 
 ### What's new