asd

GitHubActionsTestLogger.Demo.Mtp/Readme.md

@@ -3,14 +3,7 @@
 To run the demo tests, use the following command:
 
 ```console
-$ dotnet test -p:IsTestProject=true
-```
-
-In order for the reporter to work, it needs to think it's running within a GitHub Actions environment.
-You can simulate this locally by setting the `GITHUB_ACTIONS` environment variable to `true`:
-
-```powershell
-$env:GITHUB_ACTIONS="true"
+$ dotnet test -p:IsTestProject=true --github-actions
 ```
 
 To produce a test summary, provide the output file path by setting the `GITHUB_STEP_SUMMARY` environment variable:

GitHubActionsTestLogger.Tests/VsTestInitializationSpecs.cs

@@ -48,11 +48,11 @@ public void I_can_use_the_logger_with_a_custom_configuration()
         var events = new FakeTestLoggerEvents();
         var parameters = new Dictionary<string, string?>
         {
-            ["annotations-title-format"] = "TitleFormat",
-            ["annotations-message-format"] = "MessageFormat",
+            ["annotations-title"] = "TitleFormat",
+            ["annotations-message"] = "MessageFormat",
             ["summary-allow-empty"] = "true",
-            ["summary-include-passed-tests"] = "true",
-            ["summary-include-skipped-tests"] = "true",
+            ["summary-include-passed"] = "true",
+            ["summary-include-skipped"] = "true",
         };
 
         // Act

GitHubActionsTestLogger/MtpLogger.cs

@@ -3,6 +3,7 @@
 using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using GitHubActionsTestLogger.GitHub;
@@ -15,44 +16,51 @@
 
 namespace GitHubActionsTestLogger;
 
-internal class MtpLogger(ICommandLineOptions commandLineOptions)
-    : MtpExtensionBase,
-        // 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
+internal class MtpLogger : IDataConsumer, ITestSessionLifetimeHandler
 {
-    private readonly TestReportingContext _context = new(
-        GitHubWorkflow.Default,
-        TestReportingOptions.Resolve(commandLineOptions)
-    );
-
-    // MTP does not provide a built-in way to measure test run duration, so we do it manually
+    private readonly bool _isEnabled;
+    private readonly TestReportingContext _context;
     private readonly Stopwatch _stopwatch = new();
 
     private TestRunStartInfo? _testRunStartInfo;
     private List<TestResult> _testResults = [];
 
+    public MtpLogger(ICommandLineOptions commandLineOptions)
+    {
+        var options = MtpLoggerOptionsProvider.Resolve(out var isEnabled, commandLineOptions);
+        _isEnabled = isEnabled || GitHubEnvironment.IsRunningInActions;
+        _context = new TestReportingContext(GitHubWorkflow.Default, options);
+    }
+
+    public string Uid => "GitHubActionsTestLogger";
+
+    public string Version { get; } = typeof(MtpLogger).Assembly.TryGetVersionString() ?? "1.0.0";
+
+    public string DisplayName => "GitHub Actions Test Logger";
+
+    public string Description => "Reports test results to GitHub Actions";
+
     public Type[] DataTypesConsumed { get; } = [typeof(TestNodeUpdateMessage)];
 
+    public Task<bool> IsEnabledAsync() => Task.FromResult(_isEnabled);
+
     public Task OnTestSessionStartingAsync(
         SessionUid sessionUid,
         CancellationToken cancellationToken
     )
     {
         _stopwatch.Restart();
 
+        // MTP test host runs within the test assembly, so we can infer the test suite name
+        // and target framework directly from the assembly metadata.
         var testAssembly = Assembly.GetEntryAssembly();
+
         var testRunStartInfo = new TestRunStartInfo(
             sessionUid.Value,
-            // MTP test host runs within the test assembly, so we can infer the test suite name
-            // and target framework directly from the assembly metadata.
             testAssembly?.GetName().Name,
             testAssembly
                 ?.GetCustomAttribute<System.Runtime.Versioning.TargetFrameworkAttribute>()
-                ?.FrameworkName
+                ?.FrameworkName ?? RuntimeInformation.FrameworkDescription
         );
 
         _testRunStartInfo = testRunStartInfo;
@@ -135,7 +143,7 @@ CancellationToken cancellationToken
     )
     {
         if (_testRunStartInfo is null)
-            throw new InvalidOperationException("The test run has not been started.");
+            throw new InvalidOperationException("Test run has not been started.");
 
         _stopwatch.Stop();
 

GitHubActionsTestLogger/MtpLoggerOptionsProvider.cs

@@ -1,57 +1,110 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
+using GitHubActionsTestLogger.GitHub;
 using GitHubActionsTestLogger.Reporting;
+using GitHubActionsTestLogger.Utils.Extensions;
 using Microsoft.Testing.Platform.CommandLine;
 using Microsoft.Testing.Platform.Extensions;
 using Microsoft.Testing.Platform.Extensions.CommandLine;
 
 namespace GitHubActionsTestLogger;
 
-internal class MtpLoggerOptionsProvider : MtpExtensionBase, ICommandLineOptionsProvider
+internal partial class MtpLoggerOptionsProvider : ICommandLineOptionsProvider
 {
+    private static readonly CommandLineOption IsEnabledOption = new(
+        "github-actions",
+        $"Enables the GitHub Actions test reporter. Default is '{GitHubEnvironment.IsRunningInActions}'.",
+        ArgumentArity.Zero,
+        false
+    );
+
+    private static readonly CommandLineOption AnnotationsTitleFormatOption = new(
+        "github-actions-annotations-title-format",
+        "Specifies the title format for GitHub Annotations. See documentation for available replacement tokens. "
+            + $"Default is '{TestReportingOptions.Default.AnnotationTitleFormat}'.",
+        ArgumentArity.ExactlyOne,
+        false
+    );
+
+    private static readonly CommandLineOption AnnotationsMessageFormatOption = new(
+        "github-actions-annotations-message-format",
+        "Specifies the message format for GitHub Annotations. See documentation for available replacement tokens. "
+            + $"Default is '{TestReportingOptions.Default.AnnotationMessageFormat}'.",
+        ArgumentArity.ExactlyOne,
+        false
+    );
+
+    private static readonly CommandLineOption SummaryAllowEmptyOption = new(
+        "github-actions-summary-allow-empty",
+        "Whether to produce a summary entry for test runs where no tests were executed. "
+            + $"Default is '{TestReportingOptions.Default.SummaryAllowEmpty}'.",
+        ArgumentArity.ZeroOrOne,
+        false
+    );
+
+    private static readonly CommandLineOption SummaryIncludePassedTestsOption = new(
+        "github-actions-summary-include-passed-tests",
+        "Whether to include passed tests (in addition to failed tests) in the GitHub Actions summary. "
+            + $"Default is '{TestReportingOptions.Default.SummaryIncludePassedTests}'.",
+        ArgumentArity.ZeroOrOne,
+        false
+    );
+
+    private static readonly CommandLineOption SummaryIncludeSkippedTestsOption = new(
+        "github-actions-summary-include-skipped-tests",
+        "Whether to include skipped tests (in addition to failed tests) in the GitHub Actions summary. "
+            + $"Default is '{TestReportingOptions.Default.SummaryIncludeSkippedTests}'.",
+        ArgumentArity.ZeroOrOne,
+        false
+    );
+
+    public string Uid => "GitHubActionsTestLogger/OptionsProvider";
+
+    public string Version { get; } =
+        typeof(MtpLoggerOptionsProvider).Assembly.TryGetVersionString() ?? "1.0.0";
+
+    public string DisplayName => "GitHub Actions Test Logger Options Provider";
+
+    public string Description => "Provides command line options for the GitHub Actions Test Logger";
+
+    public Task<bool> IsEnabledAsync() => Task.FromResult(true);
+
     public IReadOnlyCollection<CommandLineOption> GetCommandLineOptions() =>
         [
-            new(
-                TestReportingOptions.CommandLineNames.AnnotationsTitleFormat,
-                $"Specifies the title format for GitHub Annotations. See documentation for available replacement tokens. "
-                    + $"Default is '{TestReportingOptions.Default.AnnotationTitleFormat}'.",
-                ArgumentArity.ExactlyOne,
-                false
-            ),
-            new(
-                TestReportingOptions.CommandLineNames.AnnotationsMessageFormat,
-                $"Specifies the message format for GitHub Annotations. See documentation for available replacement tokens. "
-                    + $"Default is '{TestReportingOptions.Default.AnnotationMessageFormat}'.",
-                ArgumentArity.ExactlyOne,
-                false
-            ),
-            new(
-                TestReportingOptions.CommandLineNames.SummaryIncludePassedTests,
-                $"Whether to include passed tests (in addition to failed tests) in the GitHub Actions summary. "
-                    + $"Default is '{TestReportingOptions.Default.SummaryIncludePassedTests}'.",
-                ArgumentArity.ZeroOrOne,
-                false
-            ),
-            new(
-                TestReportingOptions.CommandLineNames.SummaryIncludeSkippedTests,
-                $"Whether to include skipped tests (in addition to failed tests) in the GitHub Actions summary. "
-                    + $"Default is '{TestReportingOptions.Default.SummaryIncludeSkippedTests}'.",
-                ArgumentArity.ZeroOrOne,
-                false
-            ),
-            new(
-                TestReportingOptions.CommandLineNames.SummaryAllowEmpty,
-                $"Whether to produce a summary entry for test runs where no tests were executed. "
-                    + $"Default is '{TestReportingOptions.Default.SummaryAllowEmpty}'.",
-                ArgumentArity.ZeroOrOne,
-                false
-            ),
+            IsEnabledOption,
+            AnnotationsTitleFormatOption,
+            AnnotationsMessageFormatOption,
+            SummaryAllowEmptyOption,
+            SummaryIncludePassedTestsOption,
+            SummaryIncludeSkippedTestsOption,
         ];
 
     // This method is called once after all options are parsed and is used to validate the combination of options.
     public Task<ValidationResult> ValidateCommandLineOptionsAsync(
         ICommandLineOptions commandLineOptions
-    ) => ValidationResult.ValidTask;
+    )
+    {
+        if (!commandLineOptions.IsOptionSet(IsEnabledOption.Name))
+        {
+            foreach (
+                var optionName in GetCommandLineOptions()
+                    .Select(o => o.Name)
+                    .Where(n => !string.Equals(n, IsEnabledOption.Name, StringComparison.Ordinal))
+            )
+            {
+                if (commandLineOptions.IsOptionSet(optionName))
+                {
+                    return ValidationResult.InvalidTask(
+                        $"Option '--{optionName}' can only be used when '--{IsEnabledOption.Name}' is also specified."
+                    );
+                }
+            }
+        }
+
+        return ValidationResult.ValidTask;
+    }
 
     // This method is called once per option declared and is used to validate the arguments of the given option.
     // The arity of the option is checked before this method is called.
@@ -60,3 +113,36 @@ public Task<ValidationResult> ValidateOptionArgumentsAsync(
         string[] arguments
     ) => ValidationResult.ValidTask;
 }
+
+internal partial class MtpLoggerOptionsProvider
+{
+    public static TestReportingOptions Resolve(
+        out bool isEnabled,
+        ICommandLineOptions commandLineOptions
+    )
+    {
+        isEnabled = commandLineOptions.IsOptionSet(IsEnabledOption.Name);
+
+        return new TestReportingOptions
+        {
+            AnnotationTitleFormat =
+                commandLineOptions.GetOptionArgumentOrDefault(AnnotationsTitleFormatOption.Name)
+                ?? TestReportingOptions.Default.AnnotationTitleFormat,
+            AnnotationMessageFormat =
+                commandLineOptions.GetOptionArgumentOrDefault(AnnotationsMessageFormatOption.Name)
+                ?? TestReportingOptions.Default.AnnotationMessageFormat,
+            SummaryAllowEmpty =
+                commandLineOptions
+                    .GetOptionArgumentOrDefault(SummaryAllowEmptyOption.Name, "true")
+                    ?.Pipe(bool.Parse) ?? TestReportingOptions.Default.SummaryAllowEmpty,
+            SummaryIncludePassedTests =
+                commandLineOptions
+                    .GetOptionArgumentOrDefault(SummaryIncludePassedTestsOption.Name, "false")
+                    ?.Pipe(bool.Parse) ?? TestReportingOptions.Default.SummaryIncludePassedTests,
+            SummaryIncludeSkippedTests =
+                commandLineOptions
+                    .GetOptionArgumentOrDefault(SummaryIncludeSkippedTestsOption.Name, "true")
+                    ?.Pipe(bool.Parse) ?? TestReportingOptions.Default.SummaryIncludeSkippedTests,
+        };
+    }
+}