Make it possible to chain together asserts on a subject.

Description

Feature request: Make it possible to chain together asserts on a subject.

This will have the following benefits

• more fluent typing. Typing “.A” can autocomplete “Also”, while typing “;” will not autocomplete “result.” Which is needed for the next test case
• Better group relevant assertions
• less technical, and supports stream of consciousness dapping down the asserts and reading them

Complete minimal example reproducing the issue

Usually we assert we use the same variable result multiple times

E.g.

var result = a.Parts.GetStuff(parameters);
result.Code.Should().Be(1);
result.Explanation.Should().Be("");
result.Ids.Should().HaveCount(1);

I was wondering if this is easier to read and type

var result = a.Parts.GetStuff(parameters);
result
    .With.Code.Should().Be(1)
    .Also.Explanation.Should().Be("")
    .Also.Ids.Should().HaveCount(1);

I guess the With is needed to bind what Also refers back to, similar to how And refers back to the last subject

It also allows better separation of logical grouping

var result = a.Parts.GetStuff(parameters);
result
    .With.Code.Should().Be(1)
    .Also.Explanation.Should().Be("")
    .Also.Ids.Should().HaveCount(1);

result
    .With.Amount.Should().Be(400)
    .Also.AmountDetails.Should().Be("usd");

I prefer this syntax over

var result = a.Parts.GetStuff(parameters);
result.Should().BeEquivalientTo(new {
    Code = 1,
    Explanation = "",
    Ids = new []{ ?? }
});

since it has autocompletion and static typing

[jnyrup]

This is simply not possible.

var result = a.Parts.GetStuff(parameters);
result <-- we have an object of type Stuff at hand
    .With.Code.Should().Be(1) <--- we wrap it into NumericAssertions<int>
           ^-------- we're now have an int
    .Also.Explanation.Should().Be("")
            ^-- this would need to know that the int NumericAssertions<int> is wrapping, is a property on the Stuff type.

A way to write it completely fluent is with the Match assertion

result.Should()
    .Match<Stuff>(e => e.Code == 1)
    .And.Match<Stuff>(e => e.Explanation == "")
    .And.Match<Stuff>(e => e.Ids.Count == 1);

If you want to have the result of all three assertions, in case the first one fails, you can wrap them in an AssertionScope.

using(new AssertionScope())
{
	result
    	.With.Code.Should().Be(1)
	    .Also.Explanation.Should().Be("")
    	.Also.Ids.Should().HaveCount(1);
}

[jnyrup]

While I do like the idea of an even more fluent API I can’t see how this is technically possible. I’ll close this issue for now, but feel free to re-open if you have new light to shed on this.