Treating Null and Empty as the same

[danyal002]

Hello!

I have a very similar problem as this discussion post. However, it's slightly different.

I'm trying to test the mapping of a DTO to a real object using AutoMapper. AutoMapper initializes an empty object instead of null. The reason why I can't use the solution from the above link is because the type of List changes for different fields of the model. For example, in the model, there is a field called DynamicItemsGroup which is of type List<DynamicItems>. There's another field called Replacements which is of type List<Replacements>.

Is there a generalized solution for when any kind of List is empty for the Subject and the Expectation List is null, treat them as the same? I have the following code which didn't work.

subject.Should().BeEquivalentTo(expectation, opt => opt
            .Using<List<IEnumerable>>(ctx =>
            {
                if (ctx.Subject is null or { Count: 0 } && ctx.Expectation is null or { Count: 0 })
                {
                    return;
                }
                ctx.Subject.Should().BeEquivalentTo(ctx.Expectation);
            })
            .WhenTypeIs<List<IEnumerable>>());

Example of the errors that I got:

Expected property shopOffers[0].DynamicItemsGroups to be <null>, but found {empty}.
Expected property shopOffers[0].Items[1].Replacements to be <null>, but found {empty}.
Expected property shopOffers[1].DynamicItemsGroups to be <null>, but found {empty}.
Expected property shopOffers[1].Items[1].Replacements to be <null>, but found {empty}.

Thanks a lot!

[ITaluone]

Chaining .Using<T> and .WhenTypeIs<T> for all types is not an option?

[danyal002]

Yes, but that's tedious if you have a lot of properties that are nullable. It's also going to make my tests very unreadable.

[rklec]

This would be like #1825, as it seems.

[dennisdoomen]

• You could build a custom IEquivalencyStep and pass it to the Using method of the options argument.
• You could also use an anonymous object as the expectation

[danyal002]

Thanks a lot for your reply!

1. I built a custom IEquivalencyStep and passed it to the options argument, but how exactly would I be checking for empty/null List<T> in the IEquivalencyStep? I tried the following which didn't work because the srcType had > 0 properties.

var srcType = comparands.Subject?.GetType();
var destType = comparands.Expectation?.GetType();

if (srcType?.GetProperties().Any() == false && destType == null)
{
    return EquivalencyResult.AssertionCompleted;
}

return EquivalencyResult.ContinueWithNext;

2. How exactly would I use an anonymous object as the expectation?

[dennisdoomen]

Ad 1; you would need to check if the subject and expectation are collections and then use some kind of casting to check for emptiness.
Ad 2; you can build an anonymous object that has the nested properties you care about

[rklec]

@danyal002 Having the same problem, could you provide your final code here, please? The above just seems to be a snippet.

[rklec]

Okay, implemented it like this, combining the snippets above, and seems to work:

/// <summary>
/// Compares empty <see cref="IComparable{T}"/> items like <see cref="IList"/>'s treating <code>null</code> and empty collections as the same value.
/// </summary>
/// <remarks><b>Attention:</b> The content of the collection is not actually compared, this is left to the default <see cref="GenericEnumerableEquivalencyStep"/> and <see cref="EnumerableEquivalencyStep"/> of FluentAssertions.</remarks>
public class LenientCollectionEmptinessEquivalencyStep : IEquivalencyStep
{
    /// <inheritdoc />
    public EquivalencyResult Handle(Comparands comparands,
        IEquivalencyValidationContext context,
        IEquivalencyValidator nestedValidator)
    {
        var expectationType = comparands.GetExpectedType(context.Options);

        if (expectationType is null)
            return EquivalencyResult.ContinueWithNext;

        if (comparands.Subject is not ICollection && comparands.Subject is not null)
            return EquivalencyResult.ContinueWithNext;

        if (comparands.Expectation is not ICollection && comparands.Expectation is not null)
            return EquivalencyResult.ContinueWithNext;

        var typedSubject = comparands.Subject as ICollection;
        var typedExpectation = comparands.Expectation as ICollection;

        if (typedSubject is null or { Count: 0 } && typedExpectation is null or { Count: 0 })
            return EquivalencyResult.AssertionCompleted;

        return EquivalencyResult.ContinueWithNext;
    }
}

The project also has a GenericEnumerableEquivalencyStep/EnumerableEquivalencyStep, which has a IsCollection method, which may be adopted for a better guard, e.g. (null = null) equality is also handled here now as it is hard to guard against this.