Be Not Same into deep

[tisis2]

Hi there,

we switched to fluent assertion since there are a lot of advantages with that library.
now i got a usecase where i need to test a deep copy of a model. so i used the EquivalentTo which works great so far. but i also want to make sure that the object tree is not the same. so make sure that reference types are actually copied and not just the same reference.
is it possible to solve that in a generic way with fluent assertions?

thanks for your help!

[IT-VBFK]

Hoe about comparing with an anonymous object?

[jnyrup]

IEquivalencyStep is what you're looking for.
All user-registered equivalencySteps are run before the built-in, so we can guard against referential equality there.

[Fact]
public void Different_instances()
{
    // Arrange
    var subject = new A { ReferenceType = "", B = new B { PrimitiveType = 42, ValueType = default(Guid) } };
    var clone = new A { ReferenceType = "", B = new B { PrimitiveType = 42, ValueType = default(Guid) } };

    // Act / Assert
    subject.Should().BeEquivalentTo(clone, opt => opt
        .Using(new NotSameEqquivalencyStep()));
}

[Fact]
public void Same_nested_instance()
{
    // Arrange
    B b = new B { PrimitiveType = 42, ValueType = default(Guid) };
    var subject = new A { ReferenceType = "", B = b };
    var clone = new A { ReferenceType = "", B = b };

    // Act / Assert
    subject.Should().NotBeEquivalentTo(clone, opt => opt
        .Using(new NotSameEqquivalencyStep()));
}

[Fact]
public void Same_root_instance()
{
    // Arrange
    var subject = new A { ReferenceType = "", B = new B { PrimitiveType = 42, ValueType = default(Guid) } };
    var clone = subject;

    // Act / Assert
    subject.Should().NotBeEquivalentTo(clone, opt => opt
        .Using(new NotSameEqquivalencyStep()));
}

private class NotSameEqquivalencyStep : IEquivalencyStep
{
    public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationContext context, IEquivalencyValidator nestedValidator)
    {
        if (comparands.Subject is null || comparands.Expectation is null)
        {
            // I guess both being null is okay.
            return EquivalencyResult.ContinueWithNext;
        }

        if (comparands.RuntimeType.IsValueType || comparands.RuntimeType == typeof(string))
        {
            return EquivalencyResult.ContinueWithNext;
        }

        bool suceeded = Execute.Assertion
            .ForCondition(!ReferenceEquals(comparands.Subject, comparands.Expectation))
            .BecauseOf(context.Reason)
            .FailWith("Subject and Expectation should not reference the same instance in memory.");

        return suceeded
            ? EquivalencyResult.ContinueWithNext
            : EquivalencyResult.AssertionCompleted;
    }
}

private class A
{
    public string ReferenceType { get; set; }

    public B B { get; set; }
}

private class B
{
    public int PrimitiveType { get; set; }

    public Guid ValueType { get; set; }
}

[tisis2]

very nice. thanks a lot for your support :)