Async command unit tests

test/Spectre.Console.Cli.Tests/Data/Commands/AsynchronousCommand.cs

@@ -0,0 +1,28 @@
+namespace Spectre.Console.Tests.Data;
+
+public sealed class AsynchronousCommand : AsyncCommand<AsynchronousCommandSettings>
+{
+    private readonly IAnsiConsole _console;
+
+    public AsynchronousCommand(IAnsiConsole console)
+    {
+        _console = console;
+    }
+
+    public async override Task<int> ExecuteAsync(CommandContext context, AsynchronousCommandSettings settings)
+    {
+        // Simulate a long running asynchronous task
+        await Task.Delay(200);
+
+        if (settings.ThrowException)
+        {
+            throw new Exception($"Throwing exception asynchronously");
+        }
+        else
+        {
+            _console.WriteLine($"Finished executing asynchronously");
+        }
+
+        return 0;
+    }
+}

test/Spectre.Console.Cli.Tests/Data/Commands/ThrowingCommand.cs

@@ -6,8 +6,4 @@ public sealed class ThrowingCommand : Command<ThrowingCommandSettings>
     {
         throw new InvalidOperationException("W00t?");
     }
-}
-
-public sealed class ThrowingCommandSettings : CommandSettings
-{
-}
+}

test/Spectre.Console.Cli.Tests/Data/Settings/AsynchronousCommandSettings.cs

@@ -0,0 +1,8 @@
+namespace Spectre.Console.Tests.Data;
+
+public sealed class AsynchronousCommandSettings : CommandSettings
+{
+    [CommandOption("--ThrowException")]
+    [DefaultValue(false)]
+    public bool ThrowException { get; set; }
+}

test/Spectre.Console.Cli.Tests/Data/Settings/ThrowingCommandSettings.cs

@@ -0,0 +1,5 @@
+namespace Spectre.Console.Tests.Data;
+
+public sealed class ThrowingCommandSettings : CommandSettings
+{
+}

test/Spectre.Console.Cli.Tests/Unit/CommandAppTests.Async.cs

@@ -0,0 +1,70 @@
+namespace Spectre.Console.Tests.Unit.Cli;
+
+public sealed partial class CommandAppTests
+{
+    public sealed class Async
+    {
+        [Fact]
+        public async void Should_Execute_Command_Asynchronously()
+        {
+            // Given
+            var app = new CommandAppTester();
+            app.SetDefaultCommand<AsynchronousCommand>();
+            app.Configure(config =>
+            {
+                config.PropagateExceptions();
+            });
+
+            // When
+            var result = await app.RunAsync();
+
+            // Then
+            result.ExitCode.ShouldBe(0);
+            result.Output.ShouldBe("Finished executing asynchronously");
+        }
+
+        [Fact]
+        public async void Should_Handle_Exception_Asynchronously()
+        {
+            // Given
+            var app = new CommandAppTester();
+            app.SetDefaultCommand<AsynchronousCommand>();
+
+            // When
+            var result = await app.RunAsync(new[]
+                        {
+                        "--ThrowException",
+                        "true",
+                        });
+
+            // Then
+            result.ExitCode.ShouldBe(-1);
+        }
+
+        [Fact]
+        public async void Should_Throw_Exception_Asynchronously()
+        {
+            // Given
+            var app = new CommandAppTester();
+            app.SetDefaultCommand<AsynchronousCommand>();
+            app.Configure(config =>
+            {
+                config.PropagateExceptions();
+            });
+
+            // When
+            var result = await Record.ExceptionAsync(async () =>
+                    await app.RunAsync(new[]
+                        {
+                        "--ThrowException",
+                        "true",
+                        }));
+
+            // Then
+            result.ShouldBeOfType<Exception>().And(ex =>
+            {
+                ex.Message.ShouldBe("Throwing exception asynchronously");
+            });
+        }
+    }
+}