wip

GitHubActionsTestLogger/GitHubReportExtensions.cs

@@ -7,22 +7,20 @@ namespace GitHubActionsTestLogger;
 public static class GitHubReportExtensions
 {
     /// <summary>
-    /// Adds GitHub report support to the Testing Platform Builder.
+    /// Adds GitHub Actions reporting support to the Testing Platform Builder.
     /// </summary>
-    /// <param name="testApplicationBuilder">The test application builder.</param>
     public static void AddGitHubReportProvider(this ITestApplicationBuilder testApplicationBuilder)
     {
-        var extension = new GitHubTestReporterExtension();
+        var extension = new TestReporterExtension();
 
-        var compositeExtension = new CompositeExtensionFactory<GitHubTestReporter>(
-            serviceProvider => new GitHubTestReporter(
-                extension,
-                serviceProvider.GetCommandLineOptions()
-            )
+        var compositeExtension = new CompositeExtensionFactory<TestReporter>(
+            serviceProvider => new TestReporter(extension, serviceProvider.GetCommandLineOptions())
         );
         testApplicationBuilder.TestHost.AddDataConsumer(compositeExtension);
         testApplicationBuilder.TestHost.AddTestSessionLifetimeHandle(compositeExtension);
 
-        testApplicationBuilder.CommandLine.AddProvider(() => new CliOptionsProvider(extension));
+        testApplicationBuilder.CommandLine.AddProvider(
+            () => new TestReporterOptionsProvider(extension)
+        );
     }
 }

GitHubActionsTestLogger/GitHubWorkflow.cs

@@ -8,7 +8,7 @@
 namespace GitHubActionsTestLogger;
 
 // https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions
-public partial class GitHubWorkflow(TextWriter commandWriter, TextWriter summaryWriter)
+internal partial class GitHubWorkflow(TextWriter commandWriter, TextWriter summaryWriter)
 {
     private void InvokeCommand(
         string command,
@@ -78,7 +78,7 @@ public void CreateSummary(string content)
     }
 }
 
-public partial class GitHubWorkflow
+internal partial class GitHubWorkflow
 {
     public static GitHubWorkflow Default { get; } =
         new(

GitHubActionsTestLogger/TestDefinition.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace GitHubActionsTestLogger;
+
+internal record TestDefinition(
+    string Id,
+    string DisplayName,
+    IReadOnlyDictionary<string, string> Properties
+);

GitHubActionsTestLogger/TestOutcome.cs

@@ -0,0 +1,26 @@
+using Microsoft.Testing.Platform.Extensions.Messages;
+
+namespace GitHubActionsTestLogger;
+
+internal enum TestOutcome
+{
+    None,
+    Passed,
+    Failed,
+    Skipped,
+}
+
+internal static class TestOutcomeExtensions
+{
+    public static TestOutcome ToTestOutcome(this TestNodeStateProperty stateProperty) =>
+        stateProperty switch
+        {
+            PassedTestNodeStateProperty => TestOutcome.Passed,
+            FailedTestNodeStateProperty => TestOutcome.Failed,
+            ErrorTestNodeStateProperty => TestOutcome.Failed,
+            TimeoutTestNodeStateProperty => TestOutcome.Failed,
+            SkippedTestNodeStateProperty => TestOutcome.Skipped,
+            CancelledTestNodeStateProperty => TestOutcome.Skipped,
+            _ => TestOutcome.None,
+        };
+}

GitHubActionsTestLogger/TestReporter.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Testing.Platform.CommandLine;
+using Microsoft.Testing.Platform.Extensions.Messages;
+using Microsoft.Testing.Platform.Extensions.TestHost;
+using Microsoft.Testing.Platform.TestHost;
+
+namespace GitHubActionsTestLogger;
+
+/// <summary>
+/// A Microsoft.Testing.Platform extension that reports test run information to GitHub Actions.
+/// </summary>
+internal class TestReporter(TestReporterExtension extension, ICommandLineOptions commandLineOptions)
+    :
+    // This is the extension point to subscribe to data messages published to the platform.
+    // The type should then be registered as a data consumer in the test host.
+    IDataConsumer,
+        // This is the extension point to subscribe to test session lifetime events.
+        // The type should then be registered as a test session lifetime handler in the test host.
+        ITestSessionLifetimeHandler
+{
+    private readonly TestReporterContext _context = new(
+        GitHubWorkflow.Default,
+        TestReporterOptions.Resolve(commandLineOptions)
+    );
+
+    public Type[] DataTypesConsumed { get; } = [typeof(TestNodeUpdateMessage)];
+
+    public string Uid => extension.Uid;
+    public string Version => extension.Version;
+    public string DisplayName => extension.DisplayName;
+    public string Description => extension.Description;
+
+    public Task<bool> IsEnabledAsync() => extension.IsEnabledAsync();
+
+    public Task ConsumeAsync(
+        IDataProducer dataProducer,
+        IData value,
+        CancellationToken cancellationToken
+    )
+    {
+        if (value is not TestNodeUpdateMessage message)
+            throw new InvalidOperationException(
+                $"Unexpected data type: {value.GetType().FullName}"
+            );
+
+        var state = message.TestNode.Properties.SingleOrDefault<TestNodeStateProperty>();
+        if (state is null)
+            throw new InvalidOperationException("Test node state property is missing.");
+
+        _context.HandleTestResult(
+            new TestResult(
+                new TestDefinition(
+                    message.TestNode.Uid.Value,
+                    message.TestNode.DisplayName,
+                    message
+                        .TestNode.Properties.OfType<TestMetadataProperty>()
+                        .ToDictionary(p => p.Key, p => p.Value)
+                ),
+                state.ToTestOutcome(),
+                state switch
+                {
+                    FailedTestNodeStateProperty failedState => failedState.Exception,
+                    ErrorTestNodeStateProperty errorState => errorState.Exception,
+                    TimeoutTestNodeStateProperty timeoutState => timeoutState.Exception,
+                    _ => null,
+                }
+            )
+        );
+
+        return Task.CompletedTask;
+    }
+
+    public Task OnTestSessionStartingAsync(
+        SessionUid sessionUid,
+        CancellationToken cancellationToken
+    ) => Task.CompletedTask;
+
+    public Task OnTestSessionFinishingAsync(
+        SessionUid sessionUid,
+        CancellationToken cancellationToken
+    )
+    {
+        _context.HandleTestRunComplete();
+        return Task.CompletedTask;
+    }
+}