BeXmlSerializable does not respect XmlIgnoreAttribute

[sa-he]

Description

BeXmlSerializable creates a clone using XmlSerializer. XmlSerializer ignores members marked by XmlIgnoreAttribute.

The resulting clone is compared with the original. But this comparison does NOT ignore members marked by XmlIgnoreAttibute.

Reproduction Steps

public class DemoData
{
    public string Id { get; set; }

    [XmlIgnore]
    public Guid IdWrapper
    {
        get => Guid.Parse(this.Id);
        set => this.Id = value.ToString();
    }

    [XmlIgnore]
    public string IgnoreMe { get; set; }

    public string Name { get; set; }
}

// Arrange
var sut = new DemoData { Id = "m2", Name = "test 2", IgnoreMe = "ignore me" };

// Act
sut.Should().BeXmlSerializable();

Expected behavior

Test should succeed.

Actual behavior

Test fails.

Regression?

No response

Known Workarounds

No response

Configuration

FluentAssertions Version="6.12.0"
MSTest.TestAdapter/Framework Version="2.2.8"
net472 and net6.0-windows

Other information

No response

Are you willing to help with a pull-request?

No

[tacosontitan]

I'm not sure this is an issue with the process not ignoring members. Based on the code for the BeXmlSerializable method, it looks like this is working as expected and equivalency is failing:

fluentassertions/Src/FluentAssertions/ObjectAssertionsExtensions.cs

Lines 100 to 121 in 060c463

	public static AndConstraint<ObjectAssertions> BeXmlSerializable(this ObjectAssertions assertions, string because = "",
	params object[] becauseArgs)
	{
	try
	{
	object deserializedObject = CreateCloneUsingXmlSerializer(assertions.Subject);
	deserializedObject.Should().BeEquivalentTo(assertions.Subject,
	options => options.RespectingRuntimeTypes().IncludingFields().IncludingProperties());
	}
	catch (Exception exc)
	{
	Execute.Assertion
	.BecauseOf(because, becauseArgs)
	.FailWith("Expected {0} to be serializable{reason}, but serialization failed with:"
	+ Environment.NewLine + Environment.NewLine + "{1}.",
	assertions.Subject,
	exc.Message);
	}
	return new AndConstraint<ObjectAssertions>(assertions);
	}

According to line 107 there, the deserialized object should be equivalent to the subject of the assertion. This, combined with my (albeit severely lacking) understanding of how the equivalency test works, should (currently) fail because the ignored members won't be set in the deserialized object.

@dennisdoomen, can this be assigned to me?

[tacosontitan]

After further investigation, this is certainly not an issue with XML serialization, but rather how the assertion process handles equivalency:

As my screenshot shows, ignored members are not set during the deserialization process, and as a result the equivalency will fail. I am currently researching how involved of a change it would be to add support for this. I think the most surgical route would be to update EquivalencyOptions<TExpectation> to exclude ignored members and the BeXmlSerializable method to specify this as part of its options:

deserializedObject.Should().BeEquivalentTo(assertions.Subject, 
    static options => options
        .RespectingRuntimeTypes()
        .IncludingFields()
        .IncludingProperties()
        .ExcludeIgnoredMembers());

My biggest remaining question is if this new method should be specific to XML or not as ExcludeXmlIgnoredMembers for clarity that other serialization methods are not supported.

[tacosontitan]

I've defined a unit test to cover this scenario and opened a draft PR to begin working this in full. I simply need guidance on the following to prove as effective as possible on the issue:

• Should this be added to the EquivalencyOptions model?
  • If so:
    • What should the name of the method be?
      • I recommend ExcludeXmlIgnoredMembers.
    • Are there any niche references of this that I need to be careful about?
  • If not:
    • How should this be accounted for?
• Are there any ecosystem-wide scenarios or goals I need to keep in mind?
• Are there any known gotchas with the BeXmlSerializable method?
• Is there anything else I should be aware of prior to proceeding?

[dennisdoomen]

I think a simpler approach could be to add a custom IMemberSelectionRule that is based on AllPropertiesSelectionRule and AllFieldsSelectionRule and filters out properties and fields marked with the XmlIgnore attribute.

[sa-he]

Is it possible to choose an implementation that also enables BeEquivalentTo to optionally ignore properties with the XmlIgnoreAttribute?