Idea for new collection assertion

Hello, fluentassertions community,

I would like to propose a new overload of the BeEquivalentTo method for collection assertions. Here’s an example:

plannedOrders.Should().BeEquivalentTo(
    order => order.Type == OrderType.Purchase && order.Quantity == 5 && order.Date == tomorrow,
    order => order.Type == OrderType.Transfer && order.SourceLocation == distributionCenter && order.Quantity == 3 && order.Date == today,
    order => order.Type == OrderType.Transfer && order.SourceLocation == factory && order.Quantity == 5 && order.Date == today.AddDays(10)
);

Basically, the API should be similar to the existing collection.Should().BeEquivalentTo() API but instead of providing a collection of elements as input we would instead provide a collection of predicates that elements of the collection must match. Assertion should pass if it is possible to have a 1-1 mapping between elements of the collection and the predicates.

The proposed API is useful in scenarios when the collection has elements with many properties but only few of these are insteresting in the scope of a given test scenario.

Could you please let me know if there is interest in the community in this feature? I would be happy to contribute.

Best regards, Vanya

[jnyrup]

I can only agree on your analysis.

I’m not sure if BeEquivalentTo is the best method to overload, as I would say that an item is not equivalent to a predicate, but matches or satisfies it. This is just my immediate gut feeling, which isn’t necessarily right, but just that I’m not (yet) convinced. Sometimes a proposed API just needs a bit of time to sink in. On the other hand we already have Contain(Expression<Func<T, bool>> predicate).

The verbosity of SatisfyRespectively is to provide more detailed failure messages. An example from the tests:

public void When_asserting_collection_does_not_satisfy_any_inspector_it_should_throw()
{
    // Arrange
    var customers = new[]
    {
        new CustomerWithItems { Age = 21, Items = new[] { 1, 2 } },
        new CustomerWithItems { Age = 22, Items = new[] { 3 } }
    };

    // Act
    Action act = () => customers.Should().SatisfyRespectively(
        new Action<CustomerWithItems>[]
        {
            customer =>
            {
                customer.Age.Should().BeLessThan(21);
                customer.Items.Should().SatisfyRespectively(
                    item => item.Should().Be(2),
                    item => item.Should().Be(1));
            },
            customer =>
            {
                customer.Age.Should().BeLessThan(22);
                customer.Items.Should().SatisfyRespectively(item => item.Should().Be(2));
            }
        }, "because we want to test {0}", "nested assertions");

    // Assert
    act.Should().Throw<XunitException>().WithMessage(
@"Expected customers to satisfy all inspectors because we want to test nested assertions, but some inspectors are not satisfied:
*At index 0:
*Expected customer.Age to be less than 21, but found 21
*Expected customer.Items to satisfy all inspectors, but some inspectors are not satisfied:
*At index 0:
*Expected item to be 2, but found 1
*At index 1:
*Expected item to be 1, but found 2
*At index 1:
*Expected customer.Age to be less than 22, but found 22
*Expected customer.Items to satisfy all inspectors, but some inspectors are not satisfied:
*At index 0:
*Expected item to be 2, but found 3"
);
}

[vanya-lebedev]

I have created a pull request with the suggested implementation. Looking forward to your comments. https://github.com/fluentassertions/fluentassertions/pull/1500