How to use BeEquivalentTo for 2 DTOs, both having an Id property, but one of type Guid, the other with this same Guid converted to string

[icraftsoftware]

Hello,

Given these 2 types, I am struggling to validate that 2 instances of these types are equivalent using .BeEquivalentTo().

public class PocoContract
{
   public Guid Id { get; set; }
   public Decimal Amount { get; set; }
}
public class ProtobufContract
{
   public string Id { get; set; }
   public float Amount { get; set; }
}

Let us suppose the following test, where all assertions that I'd really like to write fail.

[Fact]
public void PocoVsProto()
{
   var poco = new PocoContract { Id = Guid.NewGuid(), Amount = 123M };
   var proto = new ProtobufContract { Id = poco.Id.ToString(), Amount = (float) poco.Amount };

   // following assertion fails with Expected property poco.Id to be System.String, but found System.Guid.
   poco.Should().BeEquivalentTo(proto);

   // following assertion fails with Expected property proto.Id to be {08081ed6-5462-44ac-9d06-264809a8d5c4}, but found "08081ed6-5462-44ac-9d06-264809a8d5c4".
   proto.Should().BeEquivalentTo(poco);

   // following assertion fails with Expression <pc.Id.ToString()> cannot be used to select a member. (Parameter 'expression')
   proto.Should().BeEquivalentTo(poco, options => options
      .WithMapping<ProtobufContract>(pc => pc.Id.ToString(), pb => pb.Id)
      .WithMapping<ProtobufContract>(pc => pc.Amount, pb => (decimal) pb.Amount)); // not necessary as float/decimal conversion is handled by .BeEquivalentTo()

   // following assertions obviously pass, but ugh...
   proto.Id.Should().Be(poco.Id.ToString());
   proto.Amount.Should().Be((float) poco.Amount); // again, not necessary as float/decimal conversion is handled by .BeEquivalentTo()
   proto.Should().BeEquivalentTo(poco, options => options.Excluding(o => o.Id));
}

I understand that I was trying to abuse the .WitMapping() option, but sadly, the cast to decimal is accepted, but the call to the .ToString() method is not.
Obviously this example is a little bit contrived, classes rarely have only 2 fields. But I wonder if it is possible not to have to resort to the last 3 assertions to achieve my goal.

Thank you!

François

[IT-VBFK]

What happens with:

.WithMapping<ProtobufContract>(pc => pc.Id, pb => pb.Id.ToString())

or other way round

.WithMapping<ProtobufContract>(pc => Guid.Parse(pc.Id), pb => pb.Id)

(As I understand the example pc.Id.ToString() is redundant, because it's a string before)

[icraftsoftware]

I tried already. Basically fluentassertions always complain that Expression ... cannot be used to select a member. whether it is .ToString() or Guid.Parse(). :(

[IT-VBFK]

What about my first snippet? Because there it's only the property without any operation.

Edit: Ah.. there it's the second expression which is complaining, isn't it?

[IT-VBFK]

Another way could be this: https://fluentassertions.com/objectgraphs/#equivalency-comparison-behavior

I am talking about the .Using().WhenTypeIs() construct.

LIke:

.Using<Guid>(ctx => ctx.Subject.Shoud().Be(expectedGuid))
.WhenTypeIs<Guid>()

[icraftsoftware]

That does not seem to be of concern. I need to compare a string and a guid, not refine either a string-to-string or a guid-to-guid assertion. Or am I missing something?

[IT-VBFK]

Yes? The fact, that you can cast inside the .Using()?

[icraftsoftware]

Cast to what? The using merely states that bool subject and expectation are of the same type, i.e. the one passed to using<>. I might be blind here, but I can't make it work...

[dennisdoomen]

Did you try WithAutoConversion?

[IT-VBFK]

I played around a bit...

And nothing worked except of:

proto.Should().BeEquivalentTo(poco, opt => opt
    .Using(new GuidAndStringEquivalencyStep()));

private class GuidAndStringEquivalencyStep : IEquivalencyStep
{
    public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationContext context, IEquivalencyValidator nestedValidator)
    {
        if (comparands.Subject is ProtobufContract a && comparands.Expectation is PocoContract b)
        {
            a.Id.Should().Be(b.Id.ToString());

            return EquivalencyResult.AssertionCompleted;
        }

        return EquivalencyResult.ContinueWithNext;
    }
}

The only "drawback" is: you are tied to this specific types..

[icraftsoftware]

Thanks, it surely helps!
BUT then it only compares the Id property and ignore all the others. So this is a partial solution. :(

[icraftsoftware]

The funny thing is that the .ToString() is not even required! The following just work:

var x = Guid.NewGuid();
var y = x.ToString();
x.Should().Be(y);

How come then? This can't possibly be relying on Convert.ChangeType...

[ITaluone]

BUT then it only compares the Id property and ignore all the others. So this is a partial solution. :(

Yes.. there should be some work left for you ;) This was a hint into the "right" direction

[dennisdoomen]

That's because WithAutoConversion tried to use Convert.ChangeType to convert the type of the subject-under-test to the expectation, but I don't think you can convert a decimal to a float like that. You would have to use a Using/WhenTypeIs (as explained here) to address that. WithMapping isn't going to help here as it only exists to map properties with difference names

[icraftsoftware]

WithAutoConversion is not required per se to handle the float/decimal conversion. It works without it.

[dennisdoomen]

No, it doesn't. But the big problem is that although auto-conversion works for decimal to float conversions, it doesn't work for Guid to string conversions because the former doesn't implement IConvertible.

[icraftsoftware]

@dennisdoomen
But yet this works! How come, since Guid does not support IConvertible?

var x = Guid.NewGuid();
var y = x.ToString();
x.Should().Be(y);

It would be nice if we could pass 1 (subject-to- expectation) or 2 (otherway-around) conversion lambdas to .WithAutoConversionFor. Could this be a future feature?

[dennisdoomen]

But yet this works! How come, since Guid does not support IConvertible?

That's because GuidAssertions.Be has an overload that takes a string, and tries to parse that string into a Guid.

[icraftsoftware]

Well I played a little more with the material that @IT-VBFK gave me. The following is the least ugly solution that I could come with... but I am not even sure it is worth the trouble:

public class PocoContract
{
	public Guid Id { get; set; }
	public decimal Amount { get; set; }
	public string Currency { get; set; }
}

public class ProtobufContract
{
	public string Id { get; set; }
	public float Amount { get; set; }
	public string Currency { get; set; }
}

public class ContractFixture
{
	[Fact]
	public void MessagesAreEquivalent()
	{
		var poco = new PocoContract { Id = Guid.NewGuid(), Amount = 123.45M, Currency = "EUR" };
		var proto = new ProtobufContract { Id = poco.Id.ToString(), Amount = 123.45f, Currency = "EUR" };

		poco.Should().BeEquivalentTo(proto, static options => options.Using(new PocoAndProtobufContractEquivalencyStep()));

		proto.Should().BeEquivalentTo(poco, static options => options.Using(new PocoAndProtobufContractEquivalencyStep()));
	}
}

internal class PocoAndProtobufContractEquivalencyStep : IEquivalencyStep
{
	public EquivalencyResult Handle(Comparands comparands, IEquivalencyValidationContext context, IEquivalencyValidator nestedValidator)
	{
		var poco = comparands.Subject as PocoContract ?? comparands.Expectation as PocoContract;
		var proto = comparands.Subject as ProtobufContract ?? comparands.Expectation as ProtobufContract;
		if (poco is null || proto is null) return EquivalencyResult.ContinueWithNext;
		poco.Id.Should().Be(proto.Id);
		poco.Should().BeEquivalentTo(proto, static options => options.Excluding(static r => r.Id));
		return EquivalencyResult.AssertionCompleted;
	}
}

The following do not work:

poco.Should().BeEquivalentTo(proto, static options => options.WithAutoConversion());
proto.Should().BeEquivalentTo(poco, static options => options.WithAutoConversion());

Out of curiosity, the Guid/string and float/decimal can individually be compared as such:

poco.Id.Should().Be(proto.Id);
proto.Id.Should().Be(poco.Id.ToString());

poco.Amount.Should().Be((decimal) proto.Amount);
proto.Amount.Should().Be((float) poco.Amount);

@dennisdoomen, would you care to comment, as comparing a Guid to a string works OTB but not through the .BeEquivalentTo? And then there would probably be the issue of comparing a string to a Guid through .BeEquivalentTo...

It would be nice if we could pass a pair of conversion lambdas to .WithAutoConversionFor.

Thank you!

[ITaluone]

With v7 (and/or latest alpha) you can do following:

poco.Should().Satisfy<PocoContract>(x =>
{
    x.Id.ToString().Should().Be(expectation.Id);
    x.Should().BeEquivalentTo(expectation, opt => opt.Excluding(e => e.Id));
});

[icraftsoftware]

that was part of my initial question :(

[dennisdoomen]

It would be nice if we could pass a pair of conversion lambdas to .WithAutoConversionFor.

That would be a nice feature indeed. You could suggest a feature request for that.