feat: add StatusAsync method for logging status with cancellation support and implement tests

Author: WolfBublitz

src/Extensions/ILoggerExtensions.cs

@@ -106,4 +106,37 @@ public static async Task ProgressAsync(this ILogger @this, Func<Progress, Task>
 
         await finishedPayload.WaitForFinishedAsync().ConfigureAwait(false);
     }
+
+    /// <summary>
+    /// Logs a <see cref="Status"/> to the console.
+    /// </summary>
+    /// <param name="this">The <see cref="ILogger"/> instance to log the status to.</param>
+    /// <param name="action">An action that receives the <see cref="Status"/> instance to configure it and add tasks to it.</param>
+    /// <param name="cancellationToken">A cancellation token that can be used to cancel the status operation.</param>
+    /// <returns>A <see cref="Task"/> that represents the asynchronous status operation.</returns>
+    public static async Task StatusAsync(this ILogger @this, Func<Status, Task> action, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(@this);
+        ArgumentNullException.ThrowIfNull(action);
+
+        StatusStartPayload startPayload = new()
+        {
+            CancellationToken = cancellationToken,
+        };
+
+        @this.Log(null, startPayload);
+
+        Status status = await startPayload.WaitForStatusAsync().ConfigureAwait(false);
+
+        await action(status).ConfigureAwait(false);
+
+        StatusFinishedPayload finishedPayload = new()
+        {
+            CancellationToken = cancellationToken,
+        };
+
+        @this.Log(null, finishedPayload);
+
+        await finishedPayload.WaitForFinishedAsync().ConfigureAwait(false);
+    }
 }

src/SpectreConsoleLogSink.cs

@@ -12,6 +12,8 @@ public sealed class SpectreConsoleLogSink : AsyncLogSinkBase<IAnsiConsole>
 {
     private readonly ProgressConsoleMessageWriter progressConsoleMessageWriter = new();
 
+    private readonly StatusConsoleMessageWriter statusConsoleMessageWriter = new();
+
     // ┌─────────────────────────────────────────────────────────────────────────────┐
     // │ Public Constructors                                                         │
     // └─────────────────────────────────────────────────────────────────────────────┘
@@ -24,5 +26,7 @@ public SpectreConsoleLogSink() : base(new SpectreConsoleLogMessageWriter<object>
         RegisterLogMessageWriter(new PayloadLogMessageWriter());
         RegisterLogMessageWriter<ProgressStartPayload>(progressConsoleMessageWriter);
         RegisterLogMessageWriter<ProgressFinishedPayload>(progressConsoleMessageWriter);
+        RegisterLogMessageWriter<StatusStartPayload>(statusConsoleMessageWriter);
+        RegisterLogMessageWriter<StatusFinishedPayload>(statusConsoleMessageWriter);
     }
 }

tests/ExtensionsTests/src/ILoggerExtensionsTests/StatusAsyncMethodTests.cs

@@ -0,0 +1,40 @@
+using System.Threading.Tasks;
+using AwesomeAssertions;
+using Spectre.Console;
+using Spectre.Console.Testing;
+using WB.Logging;
+using WB.Logging.LogSinks.Console.Spectre;
+
+namespace ExtensionsTests.ILoggerExtensionsTests.StatusAsyncMethodTests;
+
+public sealed class TheStatusAsyncMethod
+{
+    [Test]
+    public async Task ShouldRunAStatus()
+    {
+        // Arrange
+        TestConsole testConsole = new();
+        ILogger logger = new Logger("test");
+        logger.AttachSpectreConsole(logSink =>
+        {
+            logSink.Writer = testConsole;
+        });
+
+        // Act
+        await logger.StatusAsync(async status =>
+        {
+            await status.StartAsync("status", async context =>
+            {
+                for (int i = 0; i < 100; i++)
+                {
+                    context.Status($"Processing... {i}%");
+                    await Task.Delay(10);
+                }
+            }).ConfigureAwait(false);
+        });
+        await logger.FlushAsync();
+
+        // Assert
+        testConsole.Output.Should().Contain("Processing...");
+    }
+}