Assert AggregateExceptions with multiple InnerExceptions

[d-57u3ndl]

In the official documentation I could find the information, that AggregateExceptions are automatically unwrapped.
But without any code snippets. (https://fluentassertions.com/exceptions/#automatic-aggregateexception-unwrapping)

With my current syntax, I would rather think that I would assert an InvalidOperationException with another InvalidOperationException as InnerException.

Is there a more descriptive syntax in Version 6.2.0 (or above) to assert AggregateExceptions with multiple InnerExceptions?
Assertion in Version 6.2.0:

(await FluentActions.Awaiting(() => _myGateway.LoadAsync())
   .Should()
   .ThrowExactlyAsync<InvalidOperationException>())
   .WithMessage("Request to API failed.")
   .WithInnerException<InvalidOperationException>()
   .WithMessage(expectedMessage); 

In my opinion, the syntax was more readable in version 5.4.1.
Assertion in Version 5.4.1:

((Func<Task>)(async () => await _myGateway.LoadAsync()))
    .Should()
    .ThrowExactly<AggregateException>()
    .WithInnerException<InvalidOperationException>()
    .WithMessage("Request to API failed.")
    .WithInnerException<InvalidOperationException>()
    .WithMessage(expectedMessage);

Is there a similar notation for this assertion in version 6.2.0 as in version 5.4.1?

[d-57u3ndl]

@rizi

[dennisdoomen]

What stops you from writing:

Func<Task> act = () => _myGateway.LoadAsync();

await act.Should().ThrowExactlyAsync<InvalidOperationException>()
    .WithnnerException<InvalidOperation>()
    .WithMessage("Request to API failed.")
    .WithInnerException<InvalidOperationException>()
    .WithMessage(expectedMessage);

[d-57u3ndl]

Sorry, I gave an missleading example...
How can we assert the InnerExceptions from an AggregateException?
In my examples, I could only assert the first InnerException of the AggregateException.

public class FluentTest
{
    public async Task ProduceExceptionAsync()
    {
        Task task1 = Task.Run(() => throw new InvalidOperationException("1"));
        Task task2 = Task.Run(() => throw new InvalidOperationException("2"));
        await Task.WhenAll(task1, task2);
    }
    public async Task ProduceExceptionAsync2()
    {
        Task task1 = Task.Run(() => throw new InvalidOperationException("1"));
        Task task2 = Task.Run(() => throw new InvalidOperationException("2"));
        Task combinedTasks = Task.WhenAll(task1, task2);
        try
        {
            await combinedTasks;
        }
        catch (Exception)
        {
            if (combinedTasks.Exception != null)
                throw combinedTasks.Exception;
            throw;
        }
    }
    public void ProduceException()
    {
        List<string> list = new List<string>
                            {
                                "1",
                                "2"
                            };
        Parallel.ForEach(list, entry => throw new InvalidOperationException(entry));
    }
    public void ProduceException2()
    {
        throw new AggregateException(new List<Exception>
                                     {
                                         new InvalidOperationException("1"),
                                         new InvalidOperationException("1")
                                     });
    }
}

[TestClass]
public class FluentTestBehaviour
{
    private FluentTest _fluentTest;
    [TestInitialize]
    public void Initialize()
    {
        _fluentTest = new FluentTest();
    }
    [TestMethod]
    public async Task ProduceExceptionAsync_Should_ThrowAnInvalidOperationException()
    {
        //Working
        //act && assert
        await FluentActions.Awaiting(() => _fluentTest.ProduceExceptionAsync())
            .Should()
            .ThrowExactlyAsync<InvalidOperationException>()
            .WithMessage("1");
    }
    [TestMethod]
    public async Task ProduceExceptionAsync2_Should_ThrowAnAggregateExceptionWithTwoInvalidOperationExceptions()
    {
        //Not Working
        //act && assert
        (await FluentActions.Awaiting(() => _fluentTest.ProduceExceptionAsync2())
                .Should()
                .ThrowExactlyAsync<AggregateException>())
            .WithInnerException<InvalidOperationException>()
            .WithMessage("1")
            .WithInnerException<InvalidOperationException>()
            .WithMessage("2"); // How can I assert InvalidOperationException with Message 2;
    }
    [TestMethod]
    public void ProduceException_Should_ThrowAnInvalidOperationException()
    {
        //Working
        //act && assert
        FluentActions.Invoking(() => _fluentTest.ProduceException())
            .Should().ThrowExactly<AggregateException>()
            .WithInnerException<InvalidOperationException>();
    }
    [TestMethod]
    public void ProduceException2_Should_ThrowAnInvalidOperationException()
    {
        //Not Working
        //act && assert
        FluentActions.Invoking(() => _fluentTest.ProduceException2())
            .Should().ThrowExactly<AggregateException>()
            .WithInnerException<InvalidOperationException>()
            .WithMessage("1")
            .WithInnerException<InvalidOperationException>()
            .WithMessage("2"); // How can I assert InvalidOperationException with Message 2
    }
}

[dennisdoomen]

The below verifies that the first InvalidOperationException has an inner exception on its own of type InvalidOperationException. But that's not what you meant.

FluentActions.Invoking(() => _fluentTest.ProduceException2())
    .Should().ThrowExactly<AggregateException>()
    .WithInnerException<InvalidOperationException>()
    .WithMessage("1")
    .WithInnerException<InvalidOperationException>()
    .WithMessage("2"); // How can I assert InvalidOperationException with Message 2

Instead use this:

FluentActions.Invoking(() => _fluentTest.ProduceException2())
    .Should().ThrowExactly<AggregateException>()
    .WithInnerException<InvalidOperationException>()
    .WithMessage("1");

FluentActions.Invoking(() => _fluentTest.ProduceException2())
    .Should().ThrowExactly<AggregateException>()
    .WithInnerException<InvalidOperationException>()
    .WithMessage("2"); 

Or, since ShouldThrow will automatically unwrap the AggregateException, skip the first ThrowExactly completely

FluentActions.Invoking(() => _fluentTest.ProduceException2())
    .Should().Throw<InvalidOperationException>()
    .WithMessage("1");

FluentActions.Invoking(() => _fluentTest.ProduceException2())
    .Should().Throw<InvalidOperationException>()
    .WithMessage("2"); 

[d-57u3ndl]

Thanks, for your quick response.

Maybe I'm misunderstanding something, but the second assertion still fails in my test.
I have tested this exact code snippet before.

[TestMethod]
public void ProduceException2_Should_ThrowAnInvalidOperationException()
{
    //Not Working
    //act && assert
    FluentActions.Invoking(() => _fluentTest.ProduceException2())
        .Should().Throw<InvalidOperationException>()
        .WithMessage("1")
    FluentActions.Invoking(() => _fluentTest.ProduceException2())
        .Should().Throw<InvalidOperationException>()
        .WithMessage("2"); // Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException:
                           // Expected exception message to match the equivalent of "2", but "1" does not.
}

The example using Should().ThrowExactly() also fails.

[dennisdoomen]

That's because ProduceException2 throws two instances of InvalidOperationException which Message is 1

[d-57u3ndl]

Oh sorry my fault, obviously a typo crept in while trying it out.
Thanks again!