Assertions on different properties of object

[mu88]

Hi 👋🏻

Please have a look at the following contrived example:

public class Person
{
    public required string Name { get; init; }
    
    public required DateTime Born { get; init; }
}

public class PersonService
{
    public Person Create(string name, DateTime born) => new() { Born = born, Name = name };
}

[Fact]
public void CreatePerson()
{
    // Arrange
    var testee = new PersonService();
    
    // Act
    var result = testee.Create("Dynamo", 12.April(1953));

    // Assert
    // does not compile: result.Name.Should().Be("Dynamo").And.Born.Should.BeAfter(10.April(1953));
    // does not compile: result.Should().Satisfy(
    //     person => person.Name.Should().Be("Dynamo"),
    //     person => person.Born.Should.BeAfter(10.April(1953)
    //     );
    result.Should().Match<Person>(person => person.Name == "Dynamo" && person.Born > 10.April(1953));
}

I'd like to make assertions on an object's properties of different types (here string and DateTime) and thereby make use of FluentAssertions' wonderful extensions, e. g. .BeAfter().
But all I came up with is the very last line of the snippet and I'm wondering whether there is a more elegant way so that I can keep using the type-specific assertions?

Thank you

[jnyrup]

For the contrived example, I would probably just go with

subject.Name.Should().Be("Dynamo");
subject.Born.Should().BeAfter(10.April(1953));

But I imagine the real scenario is more complex and the subject is a result of another assertion.
E.g. using ContainSingle().Which

Currently I've this kind of code several places 😞

var person = persons.Should().ContainSingle().Which;
person.Name.Should().Be("Dynamo");
person.Born.Should().BeAfter(10.April(1953));

It would be nice to allow further chaining

persons.Should().ContainSingle()
    .Which.Should().Satisfy(p =>
    {
        p.Name.Should().Be("Dynamo");
        p.Born.Should().BeAfter(10.April(1953));
    });

[mu88]

But person.Should().ContainSingle() does not compile as it is not a collection

[jnyrup]

That's why I wrote persons in plural 😉

[mu88]

But how does that relate to my question? 😉

[jnyrup]

There's nothing wrong in writing

subject.Name.Should().Be("Dynamo");
subject.Born.Should().BeAfter(10.April(1953));

One doesn't need to chain every assertion together.

The example with persons being a IEnumerable<Person> is that not having a chainable API for doing multiple assertions on a item retrieved by Which, to my knowledge forces one to save the result of Which into a local variable and then write two separate assertions.

So what I'm trying to, is making a case where the "workaround" isn't pretty or even throw unexpected exceptions as shown in the example below.

using(new AssertionScope())
{
    var person = persons.Should().ContainSingle().Which;
    person.Name.Should().Be("Dynamo"); // <-- this would throw an NRE if ContainSingle failed
    person.Born.Should().BeAfter(10.April(1953));
}

[mu88]

Of course there's nothing wrong with writing it like that:

subject.Name.Should().Be("Dynamo");
subject.Born.Should().BeAfter(10.April(1953));

But think about a deeper object graph, e. g. Person.Address.City.Major.Person (being a Person as well). Now you can do the following:

// duplicate
Person.Address.City.Major.Person.Name.Should().Be("Dynamo");
Person.Address.City.Major.Person.Born.Should().BeAfter(10.April(1953));

// introduce temporary object
var person = Person.Address.City.Major.Person;
person.Name.Should().Be("Dynamo");
person.Born.Should().BeAfter(10.April(1953));

I'd like it if I could write:

Person.Address.City.Major.Person.Should().Satisfy(
    person => person.Name.Should().Be("Dynamo"),
    person => person.Born.Should().BeAfter(10.April(1953)
);

[jnyrup]

We have a similar API AllSatisfy for collections, we could probably mimic it just for non-collection subjects.

See it's usage

fluentassertions/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.AllSatisfy.cs

Lines 79 to 117 in 329060d

	[Fact]
	public void Any_items_not_satisfying_inspector_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()
	.AllSatisfy(
	customer =>
	{
	customer.Age.Should().BeLessThan(21);
	customer.Items.Should()
	.AllSatisfy(item => item.Should().Be(3));
	},
	"because we want to test {0}",
	"nested assertions");
	// Assert
	act.Should()
	.Throw<XunitException>()
	.WithMessage(
	@"Expected customers to contain only items satisfying the inspector because we want to test nested assertions:
	*At index 0:
	*Expected customer.Age to be less than 21, but found 21
	*Expected customer.Items to contain only items satisfying the inspector:
	*At index 0:
	*Expected item to be 3, but found 1
	*At index 1:
	*Expected item to be 3, but found 2
	*At index 1:
	*Expected customer.Age to be less than 21, but found 22 (difference of 1)"
	);
	}

[dennisdoomen]

Or use something like this:

  result.Should().BeEquivalentTo(new
  {
      Name = "Dynamo",
  }, options => options
      .Using<DateTime>(a => a.Subject.Should().BeAfter(10.April(1953)))
      .WhenTypeIs<DateTime>());