Set global ComparingByMembers/ComparingByValues

[SephVin]

Hi! How can I globally setup the strategy to using ComparingByMembers for all reference types (ignore condition type.OverridesEquals())?
I saw example: AssertionOptions.AssertEquivalencyUsing(options => options.ComparingByMembers<DirectoryInfo>());, but can i do something like this AssertionOptions.AssertEquivalencyUsing(options => options.ComparingByMembers());?

[dennisdoomen]

Did you try ComparingByMembers<object>?

[SephVin]

Thanks for your quick reply! Tried this, it seems i need to set precision for DateTime type, because this test:

public class TestClass
{
    public TestClass(DateTime dateTime)
    {
        DateTime = dateTime;
    }

    public DateTime DateTime { get; }
}

[Test]
public void Test()
{
    var testClass1 = new TestClass(1.January(2021).At(10, 01));
    var testClass2 = new TestClass(1.January(2021));

    testClass1.Should().BeEquivalentTo(testClass2);
}

fails with message when i set AssertionOptions.AssertEquivalencyUsing(options => options.ComparingByMembers<object>());

The maximum recursion depth was reached.  
The maximum recursion depth was reached.  
The maximum recursion depth was reached.  
The maximum recursion depth was reached.  
Expected property testClass1.DateTime.Hour to be 0, but found 10.
Expected property testClass1.DateTime.Minute to be 0, but found 1.
Expected property testClass1.DateTime.Ticks to be 637450560000000000L, but found 637450920600000000L.
Expected property testClass1.DateTime.TimeOfDay.Ticks to be 0L, but found 360600000000L.
Expected property testClass1.DateTime.TimeOfDay.Hours to be 0, but found 10.
Expected property testClass1.DateTime.TimeOfDay.Minutes to be 0, but found 1.
Expected property testClass1.DateTime.TimeOfDay.TotalDays to be 0.0, but found 0.41736111111111107.
Expected property testClass1.DateTime.TimeOfDay.TotalHours to be 0.0, but found 10.016666666666666.
Expected property testClass1.DateTime.TimeOfDay.TotalMilliseconds to be 0.0, but found 36060000.0.
Expected property testClass1.DateTime.TimeOfDay.TotalMinutes to be 0.0, but found 601.0.
Expected property testClass1.DateTime.TimeOfDay.TotalSeconds to be 0.0, but found 36060.0.

[dennisdoomen]

That's what's going to happen. Every type, both yours and the .NET types, will be compared by their members. But I'm pretty sure that's not what you intended. However, I'm not clear what you are trying to accomplish.

[SephVin]

I'll try to explain with this example. We have TestClass that inherits IEquatable and also override Equals, GetHashCode and ToString:

public class TestClass : IEquatable<TestClass>
{
    public TestClass(int value, DateTime dateTime)
    {
        Value = value;
        DateTime = dateTime;
    }

    public int Value { get; }
    public DateTime DateTime { get; }

    public bool Equals(TestClass? other)
    {
        if (ReferenceEquals(null, other))
            return false;
        if (ReferenceEquals(this, other))
            return true;

        return Value.Equals(other.Value) && DateTime.Equals(other.DateTime);
    }

    public override bool Equals(object? obj)
    {
        if (ReferenceEquals(null, obj))
            return false;
        if (ReferenceEquals(this, obj))
            return true;
        if (obj.GetType() != GetType())
            return false;

        return Equals((TestClass)obj);
    }

    public override int GetHashCode()
    {
        unchecked
        {
            var hashCode = Value.GetHashCode();
            hashCode = (hashCode * 397) ^ DateTime.GetHashCode();
            return hashCode;
        }
    }

    public override string ToString() => $"{nameof(Value)}: {Value}, {nameof(DateTime)}: {DateTime}";
}

And also we have test that should fail:

[Test]
public void Test()
{
    var testClass1 = new TestClass(1, 1.January(2021));
    var testClass2 = new TestClass(1, 1.January(2022));

    testClass1.Should().BeEquivalentTo(testClass2);
}

Test fail with message: Expected testClass1 to be Value: 1, DateTime: 01.01.2022 0:00:00, but found Value: 1, DateTime: 01.01.2021 0:00:00. This message is not very convenient to read, because i can't see immediately where is the problem.

But if i write test like this:

[Test]
public void Test()
{
    var testClass1 = new TestClass(1, 1.January(2021));
    var testClass2 = new TestClass(1, 1.January(2022));

    testClass1.Should().BeEquivalentTo(testClass2, options => options.ComparingByMembers<TestClass>());
}

error message will be: Expected property testClass1.DateTime to be <2022-01-01>, but found <2021-01-01>. - the message has only property with the error.

That's why I thought it was possible to globally configure ComparingByMembers (but not like this:

AssertionOptions.AssertEquivalencyUsing(
    options => options
        .ComparingByMembers<TestClass1>()
        .ComparingByMembers<TestClass2>()
        .ComparingByMembers<TestClass3>()
        .ComparingByMembers<TestClass4>()
        etc. );

Maybe i should use something else for this ?

[dennisdoomen]

It seems you're mixing up how FA compares two instances and how it renders the failure message. If your type, TestClass in this case, implements value equality (using Equals, IEquatable, etc), then we assume you want to compare two instances using those equality members. We will also use ToString to render the object in the failure message. You can customize that though. Check out the documentation on this here.

[SephVin]

Thank you!

[divega]

Hi @dennisdoomen. I think ran into the same need to apply ComparingByMembers<T>() not just to the root T but to the entire object graph. You can find more information about the motivation in #2571 (comment).

I incidentally tried ComparingByMembers<object>() before running into this discussion, but that results into many tests that I already had passing to regress to "The maximum recursion depth of 10 was reached." repeated multiple times in the exception.

I would certainly agree that I only care for the types defined in my application to get this ComparyingByMembers behavior, so I am more inclined for having a way to specify that overriding equals should not determine that a type should be compared by value. I also think it would be convinient if this was something that can be configured on a specific assertion or in a specific assertion scope rather than globally.

I even tried code like the one below, but it didn't help:

public static EquivalencyAssertionOptions<TExpectation> ExcludingByMembers<TExpectation>(this EquivalencyAssertionOptions<TExpectation> options, params string[] exclusions)
{
    using (var scope = new AssertionScope())
    {
        scope.FormattingOptions.MaxDepth = 100;
        return options
            .ComparingByMembers<object>()
            .AllowingInfiniteRecursion()
            .IgnoringCyclicReferences()
            .Excluding(memberInfo => exclusions.Any(e => memberInfo.Path.Equals(e, StringComparison.OrdinalIgnoreCase)));
    }
}

At this point, I keep looking for a workaround that will allow me to upgrade my project to the latest version of FA. Perhaps I need to try harder with the documentation 😄

cc @jnyrup.

[dennisdoomen]

Unfortunately, with this option I am still getting an exceptions with the description "The maximum recursion depth of 10 was reached." repeated 10 or 20 times in many of the tests.

That's because by default, for performance reasons, the recursion will not go beyond 10 levels deep. You can override that, but that is not recommended.

[divega]

Curious how I am supposed to override that limit. I have tried AllowInfiniteRecursion() and also setting MaxDepth on the formatting side to no avail. Not that want to do something that isn't recommended but because I am not sure I understand exactly why it's failing. Again, these are tests that were working well on FluentAssertions 5.10.3.

[dennisdoomen]

You're saying that AllowingInfiniteRecursion() doesn't work?

[divega]

Yes. In some of my tests, if I do ComparingByMembers<object>() or ComparingByMembers(typeof(IEquatable<>)), I keep getting "The maximum recursion depth of 10 was reached." multiple times in the error message, even if I call AllowingInfinteRecursion() on the options and set a scope with MaxDepth = 100 on the formatter.

FWIW, I switched to a different workaround that configures ComparingByMember more narrowly than object or IEquatable<> and this seems to be working better for me:

        private static EquivalencyAssertionOptions<TExpectation> ComparingByMembersForAllTypesInAssembly<TExpectation>(
            this EquivalencyAssertionOptions<TExpectation> options)
        {
            var types = typeof(TExpectation).Assembly.GetTypes();
            foreach (var t in types)
            {
                options.ComparingByMembers(t);
            }

            return options;
        }

I am calling this every time I need to do any property exclusion, and now all my tests are passing. But I still wish I didn't have to do this just because Excluding doesn't work without it.

Especially, I don't like the fact that I am repeating the walk through all types in the assembly for every assertion in which I need to do any exclusion. So I will try to figure out a way to avoid doing this so many times, perhaps using EquivalencyAssertionOptions<Test>.Default.

[dennisdoomen]

If that's really the case, then please submit an issue with something we can reproduce. We have tests that cover AllowingInfinteRecursion, so I'm surprised you're running in that issue.