How to migrate collection assertions from xUnit.net to TUnit?

[sliekens]

I have some tests that do assertions on an abstract syntax tree with following expectations:

• exactly 2 child nodes
• child nodes are a specific type
• child nodes have a specific value

Using Assert from xUnit.net:

[Test]
public void Ignores_invalid_tags()
{
    string input = "5 <REDACTED> Dye kits";
    IEnumerable<MarkupToken> tokens = MarkupLexer.Tokenize(input);
    RootNode actual = MarkupParser.Parse(tokens);
    Assert.NotNull(actual);
    Assert.Collection(actual.Children, node =>
    {
        TextNode text = Assert.IsType<TextNode>(node);
        Assert.Equal("5 ", text.Text);
    }, node =>
    {
        TextNode text = Assert.IsType<TextNode>(node);
        Assert.Equal(" Dye kits", text.Text);
    });
}

How can I convert it to TUnit fluent syntax?

What I tried:

[Test]
public async Task Ignores_invalid_tags()
{
    string input = "5 <REDACTED> Dye kits";
    IEnumerable<MarkupToken> tokens = MarkupLexer.Tokenize(input);
    RootNode actual = MarkupParser.Parse(tokens);
    await TUnit.Assertions.Assert.That(actual).IsNotNull();

    List<MarkupNode> children = [.. actual.Children];
    await TUnit.Assertions.Assert.That(children)
        .HasCount(2)
        .And.Member(
            children => children.ElementAt(0),
            node => node.IsTypeOf<TextNode, MarkupNode>().And.Member(u => u.Text, t => t.IsEqualTo("5 "))
        )
        .And.Member(
            children => children.ElementAt(1),
            node => node.IsTypeOf<TextNode, MarkupNode>().And.Member(u => u.Text, t => t.IsEqualTo(" Dye kits"))
        );
}

However, it fails at runtime because IsTypeOf changes the resulting assertion type.

TUnit.Engine.Exceptions.TestFailedException: InvalidOperationException: Member assertion returned unexpected type: TUnit.Assertions.Conditions.TypeOfAssertion`2[GuildWars2.Markup.MarkupNode,GuildWars2.Markup.TextNode]. Expected Assertion.

For simple cases like this, splitting this across multiple assertions instead of chaining is not a problem, but splitting gets complicated fast for multiple layers of IsTypeOf -> Member -> IsTypeOf -> Member -> IsTypeOf -> Member assertions.

--

A more complicated example:

[Test]
public void Forgives_mismatched_tags()
{
    string input = "<c=@reminder>This coat hides leg armor.<c>";
    IEnumerable<MarkupToken> tokens = MarkupLexer.Tokenize(input);
    RootNode actual = MarkupParser.Parse(tokens);
    Assert.NotNull(actual);
    MarkupNode firstChild = Assert.Single(actual.Children);
    ColoredTextNode coloredText = Assert.IsType<ColoredTextNode>(firstChild);
    Assert.Equal("@reminder", coloredText.Color);
    MarkupNode coloredTextChild = Assert.Single(coloredText.Children);
    TextNode text = Assert.IsType<TextNode>(coloredTextChild);
    Assert.Equal("This coat hides leg armor.", text.Text);
}

What I tried:

[Test]
public async Task Forgives_mismatched_tags()
{
    string input = "<c=@reminder>This coat hides leg armor.<c>";
    IEnumerable<MarkupToken> tokens = MarkupLexer.Tokenize(input);
    RootNode actual = MarkupParser.Parse(tokens);
    await TUnit.Assertions.Assert.That(actual).IsNotNull()
        .And.Member(
            a => a.Children,
            a => a.IsSingleElement()
                .And.IsTypeOf<ColoredTextNode>()
                .And.Member(n => n.Color, b => b.IsEqualTo("@reminder"))
                .And.Member(n => n.Children, b => b.HasSingleItem()
                    .And.IsTypeOf<TextNode>()
                    .And.Member(c => c.Text, d => d.IsEqualTo("This coat hides leg armor.")))
            );
}

It fails with a similar runtime error:

InvalidOperationException: Member assertion returned unexpected type: TUnit.Assertions.Conditions.MemberAssertionResult1[GuildWars2.Markup.TextNode]. Expected Assertion<IEnumerable1>.

[thomhurst]

Something like this:

      string input = "5 <REDACTED> Dye kits";
      IEnumerable<MarkupToken> tokens = MarkupLexer.Tokenize(input);
      RootNode actual = MarkupParser.Parse(tokens);

      await Assert.That(actual)
          .IsNotNull()
          .And.Member(a => a.Children, children => children.HasCount(2));

      await Assert.That(actual.Children.ElementAt(0))
          .IsTypeOf<TextNode>()
          .And.Member(t => t.Text, text => text.IsEqualTo("5 "));

      await Assert.That(actual.Children.ElementAt(1))
          .IsTypeOf<TextNode>()
          .And.Member(t => t.Text, text => text.IsEqualTo(" Dye kits"));

or

      string input = "<c=@reminder>This coat hides leg armor.<c>";
      IEnumerable<MarkupToken> tokens = MarkupLexer.Tokenize(input);
      RootNode actual = MarkupParser.Parse(tokens);

      await Assert.That(actual).IsNotNull();

      var firstChild = await Assert.That(actual.Children).HasSingleItem();

      var coloredText = await Assert.That(firstChild)
          .IsTypeOf<ColoredTextNode>()
          .And.Member(c => c.Color, color => color.IsEqualTo("@reminder"));

      var coloredTextChild = await Assert.That(coloredText.Children).HasSingleItem();

      await Assert.That(coloredTextChild)
          .IsTypeOf<TextNode>()
          .And.Member(t => t.Text, text => text.IsEqualTo("This coat hides leg armor."));

[sliekens]

Aha, I didn't know assertions return a reference to the subject when awaited. Definitely worth mentioning in https://tunit.dev/docs/assertions/awaiting. This code looks a lot neater than what I was doing because I didn't know this trick.