feat: add JUnit reporter and command provider for test results output

TUnit.Engine.Tests/JUnitReporterTests.cs

@@ -0,0 +1,120 @@
+using Microsoft.Testing.Platform.Extensions;
+using TUnit.Core;
+using TUnit.Engine.Reporters;
+
+namespace TUnit.Engine.Tests;
+
+[NotInParallel]
+public class JUnitReporterTests
+{
+    private sealed class MockExtension : IExtension
+    {
+        public string Uid => "MockExtension";
+        public string DisplayName => "Mock";
+        public string Version => "1.0.0";
+        public string Description => "Mock Extension";
+        public Task<bool> IsEnabledAsync() => Task.FromResult(true);
+    }
+
+    [After(Test)]
+    public void Cleanup()
+    {
+        // Clean up environment variables after each test
+        Environment.SetEnvironmentVariable("TUNIT_DISABLE_JUNIT_REPORTER", null);
+        Environment.SetEnvironmentVariable("TUNIT_ENABLE_JUNIT_REPORTER", null);
+        Environment.SetEnvironmentVariable("GITLAB_CI", null);
+        Environment.SetEnvironmentVariable("CI_SERVER", null);
+        Environment.SetEnvironmentVariable("JUNIT_XML_OUTPUT_PATH", null);
+    }
+
+    [Test]
+    public async Task IsEnabledAsync_Should_Return_False_When_TUNIT_DISABLE_JUNIT_REPORTER_Is_Set()
+    {
+        // Arrange
+        Environment.SetEnvironmentVariable("TUNIT_DISABLE_JUNIT_REPORTER", "true");
+        Environment.SetEnvironmentVariable("GITLAB_CI", "true"); // Even with GitLab CI, should be disabled
+        var extension = new MockExtension();
+        var reporter = new JUnitReporter(extension);
+
+        // Act
+        var isEnabled = await reporter.IsEnabledAsync();
+
+        // Assert
+        await Assert.That(isEnabled).IsFalse();
+    }
+
+    [Test]
+    public async Task IsEnabledAsync_Should_Return_True_When_GITLAB_CI_Is_Set()
+    {
+        // Arrange
+        Environment.SetEnvironmentVariable("GITLAB_CI", "true");
+        var extension = new MockExtension();
+        var reporter = new JUnitReporter(extension);
+
+        // Act
+        var isEnabled = await reporter.IsEnabledAsync();
+
+        // Assert
+        await Assert.That(isEnabled).IsTrue();
+    }
+
+    [Test]
+    public async Task IsEnabledAsync_Should_Return_True_When_CI_SERVER_Is_Set()
+    {
+        // Arrange
+        Environment.SetEnvironmentVariable("CI_SERVER", "yes");
+        var extension = new MockExtension();
+        var reporter = new JUnitReporter(extension);
+
+        // Act
+        var isEnabled = await reporter.IsEnabledAsync();
+
+        // Assert
+        await Assert.That(isEnabled).IsTrue();
+    }
+
+    [Test]
+    public async Task IsEnabledAsync_Should_Return_True_When_TUNIT_ENABLE_JUNIT_REPORTER_Is_Set()
+    {
+        // Arrange
+        Environment.SetEnvironmentVariable("TUNIT_ENABLE_JUNIT_REPORTER", "true");
+        var extension = new MockExtension();
+        var reporter = new JUnitReporter(extension);
+
+        // Act
+        var isEnabled = await reporter.IsEnabledAsync();
+
+        // Assert
+        await Assert.That(isEnabled).IsTrue();
+    }
+
+    [Test]
+    public async Task IsEnabledAsync_Should_Return_False_When_No_Environment_Variables_Are_Set()
+    {
+        // Arrange
+        var extension = new MockExtension();
+        var reporter = new JUnitReporter(extension);
+
+        // Act
+        var isEnabled = await reporter.IsEnabledAsync();
+
+        // Assert
+        await Assert.That(isEnabled).IsFalse();
+    }
+
+    [Test]
+    public async Task IsEnabledAsync_Should_Prefer_Disable_Over_Enable()
+    {
+        // Arrange
+        Environment.SetEnvironmentVariable("TUNIT_DISABLE_JUNIT_REPORTER", "true");
+        Environment.SetEnvironmentVariable("TUNIT_ENABLE_JUNIT_REPORTER", "true");
+        var extension = new MockExtension();
+        var reporter = new JUnitReporter(extension);
+
+        // Act
+        var isEnabled = await reporter.IsEnabledAsync();
+
+        // Assert
+        await Assert.That(isEnabled).IsFalse();
+    }
+}

TUnit.Engine/CommandLineProviders/JUnitReporterCommandProvider.cs

@@ -0,0 +1,50 @@
+using Microsoft.Testing.Platform.CommandLine;
+using Microsoft.Testing.Platform.Extensions;
+using Microsoft.Testing.Platform.Extensions.CommandLine;
+
+namespace TUnit.Engine.CommandLineProviders;
+
+internal class JUnitReporterCommandProvider(IExtension extension) : ICommandLineOptionsProvider
+{
+    public const string JUnitOutputPathOption = "junit-output-path";
+
+    public Task<bool> IsEnabledAsync() => extension.IsEnabledAsync();
+
+    public string Uid => extension.Uid;
+
+    public string Version => extension.Version;
+
+    public string DisplayName => extension.DisplayName;
+
+    public string Description => extension.Description;
+
+    public IReadOnlyCollection<CommandLineOption> GetCommandLineOptions()
+    {
+        return
+        [
+            new CommandLineOption(
+                JUnitOutputPathOption,
+                "Path to output JUnit XML file (default: TestResults/{AssemblyName}-junit.xml)",
+                ArgumentArity.ExactlyOne,
+                false)
+        ];
+    }
+
+    public Task<ValidationResult> ValidateOptionArgumentsAsync(
+        CommandLineOption commandOption,
+        string[] arguments)
+    {
+        if (commandOption.Name == JUnitOutputPathOption && arguments.Length != 1)
+        {
+            return ValidationResult.InvalidTask("A single output path must be provided for --junit-output-path");
+        }
+
+        return ValidationResult.ValidTask;
+    }
+
+    public Task<ValidationResult> ValidateCommandLineOptionsAsync(
+        ICommandLineOptions commandLineOptions)
+    {
+        return ValidationResult.ValidTask;
+    }
+}

TUnit.Engine/Extensions/TestApplicationBuilderExtensions.cs

@@ -21,6 +21,9 @@ public static void AddTUnit(this ITestApplicationBuilder testApplicationBuilder)
         var githubReporter = new GitHubReporter(extension);
         var githubReporterCommandProvider = new GitHubReporterCommandProvider(extension);
 
+        var junitReporter = new JUnitReporter(extension);
+        var junitReporterCommandProvider = new JUnitReporterCommandProvider(extension);
+
         testApplicationBuilder.RegisterTestFramework(
             serviceProvider => new TestFrameworkCapabilities(CreateCapabilities(serviceProvider)),
             (capabilities, serviceProvider) => new TUnitTestFramework(extension, serviceProvider, capabilities));
@@ -46,6 +49,9 @@ public static void AddTUnit(this ITestApplicationBuilder testApplicationBuilder)
         // GitHub reporter configuration
         testApplicationBuilder.CommandLine.AddProvider(() => githubReporterCommandProvider);
 
+        // JUnit reporter configuration
+        testApplicationBuilder.CommandLine.AddProvider(() => junitReporterCommandProvider);
+
         testApplicationBuilder.TestHost.AddDataConsumer(serviceProvider =>
         {
             // Apply command-line configuration if provided
@@ -58,6 +64,18 @@ public static void AddTUnit(this ITestApplicationBuilder testApplicationBuilder)
             return githubReporter;
         });
         testApplicationBuilder.TestHost.AddTestHostApplicationLifetime(_ => githubReporter);
+
+        testApplicationBuilder.TestHost.AddDataConsumer(serviceProvider =>
+        {
+            // Apply command-line configuration if provided
+            var commandLineOptions = serviceProvider.GetRequiredService<ICommandLineOptions>();
+            if (commandLineOptions.TryGetOptionArgumentList(JUnitReporterCommandProvider.JUnitOutputPathOption, out var pathArgs))
+            {
+                junitReporter.SetOutputPath(pathArgs[0]);
+            }
+            return junitReporter;
+        });
+        testApplicationBuilder.TestHost.AddTestHostApplicationLifetime(_ => junitReporter);
     }
 
     private static IReadOnlyCollection<ITestFrameworkCapability> CreateCapabilities(IServiceProvider serviceProvider)

TUnit.Engine/Reporters/JUnitReporter.cs

@@ -0,0 +1,160 @@
+using System.Collections.Concurrent;
+using System.Reflection;
+using System.Text;
+using Microsoft.Testing.Platform.Extensions;
+using Microsoft.Testing.Platform.Extensions.Messages;
+using Microsoft.Testing.Platform.Extensions.TestHost;
+using TUnit.Engine.Framework;
+using TUnit.Engine.Helpers;
+using TUnit.Engine.Xml;
+
+namespace TUnit.Engine.Reporters;
+
+public class JUnitReporter(IExtension extension) : IDataConsumer, ITestHostApplicationLifetime, IFilterReceiver
+{
+    private string _outputPath = null!;
+    private bool _isEnabled;
+
+    public async Task<bool> IsEnabledAsync()
+    {
+        // Check if explicitly disabled
+        if (EnvironmentVariableCache.Get("TUNIT_DISABLE_JUNIT_REPORTER") is not null)
+        {
+            return false;
+        }
+
+        // Check if explicitly enabled OR running in GitLab CI
+        var explicitlyEnabled = EnvironmentVariableCache.Get("TUNIT_ENABLE_JUNIT_REPORTER") is not null;
+        var runningInGitLab = EnvironmentVariableCache.Get("GITLAB_CI") is not null ||
+                              EnvironmentVariableCache.Get("CI_SERVER") is not null;
+
+        if (!explicitlyEnabled && !runningInGitLab)
+        {
+            return false;
+        }
+
+        // Determine output path
+        _outputPath = EnvironmentVariableCache.Get("JUNIT_XML_OUTPUT_PATH")
+            ?? GetDefaultOutputPath();
+
+        _isEnabled = true;
+        return await extension.IsEnabledAsync();
+    }
+
+    public string Uid { get; } = $"{extension.Uid}JUnitReporter";
+
+    public string Version => extension.Version;
+
+    public string DisplayName => extension.DisplayName;
+
+    public string Description => extension.Description;
+
+    private readonly ConcurrentDictionary<string, List<TestNodeUpdateMessage>> _updates = [];
+
+    public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationToken cancellationToken)
+    {
+        var testNodeUpdateMessage = (TestNodeUpdateMessage)value;
+
+        _updates.GetOrAdd(testNodeUpdateMessage.TestNode.Uid.Value, []).Add(testNodeUpdateMessage);
+
+        return Task.CompletedTask;
+    }
+
+    public Type[] DataTypesConsumed { get; } = [typeof(TestNodeUpdateMessage)];
+
+    public Task BeforeRunAsync(CancellationToken cancellationToken)
+    {
+        return Task.CompletedTask;
+    }
+
+    public async Task AfterRunAsync(int exitCode, CancellationToken cancellation)
+    {
+        if (!_isEnabled || _updates.Count == 0)
+        {
+            return;
+        }
+
+        // Get the last update for each test
+        var lastUpdates = new List<TestNodeUpdateMessage>(_updates.Count);
+        foreach (var kvp in _updates)
+        {
+            if (kvp.Value.Count > 0)
+            {
+                lastUpdates.Add(kvp.Value[kvp.Value.Count - 1]);
+            }
+        }
+
+        // Generate JUnit XML
+        var xmlContent = JUnitXmlWriter.GenerateXml(lastUpdates, Filter);
+
+        if (string.IsNullOrEmpty(xmlContent))
+        {
+            return;
+        }
+
+        // Write to file with retry logic
+        await WriteXmlFileAsync(_outputPath, xmlContent, cancellation);
+    }
+
+    public string? Filter { get; set; }
+
+    internal void SetOutputPath(string path)
+    {
+        _outputPath = path;
+    }
+
+    private static string GetDefaultOutputPath()
+    {
+        var assemblyName = Assembly.GetEntryAssembly()?.GetName().Name ?? "TestResults";
+        return Path.Combine("TestResults", $"{assemblyName}-junit.xml");
+    }
+
+    private static async Task WriteXmlFileAsync(string path, string content, CancellationToken cancellationToken)
+    {
+        // Ensure directory exists
+        var directory = Path.GetDirectoryName(path);
+        if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
+        {
+            Directory.CreateDirectory(directory);
+        }
+
+        const int maxAttempts = 5;
+        var random = new Random();
+
+        for (int attempt = 1; attempt <= maxAttempts; attempt++)
+        {
+            try
+            {
+#if NET
+                await File.WriteAllTextAsync(path, content, Encoding.UTF8, cancellationToken);
+#else
+                File.WriteAllText(path, content, Encoding.UTF8);
+#endif
+                Console.WriteLine($"JUnit XML report written to: {path}");
+                return;
+            }
+            catch (IOException ex) when (attempt < maxAttempts && IsFileLocked(ex))
+            {
+                var baseDelay = 50 * Math.Pow(2, attempt - 1);
+                var jitter = random.Next(0, 50);
+                var delay = (int)(baseDelay + jitter);
+
+                Console.WriteLine($"JUnit XML file is locked, retrying in {delay}ms (attempt {attempt}/{maxAttempts})");
+                await Task.Delay(delay, cancellationToken);
+            }
+        }
+
+        Console.WriteLine($"Failed to write JUnit XML report to: {path} after {maxAttempts} attempts");
+    }
+
+    private static bool IsFileLocked(IOException exception)
+    {
+        // Check if the exception is due to the file being locked/in use
+        // HResult 0x80070020 is ERROR_SHARING_VIOLATION on Windows
+        // HResult 0x80070021 is ERROR_LOCK_VIOLATION on Windows
+        var errorCode = exception.HResult & 0xFFFF;
+        return errorCode == 0x20 || errorCode == 0x21 ||
+               exception.Message.Contains("being used by another process") ||
+               exception.Message.Contains("access denied", StringComparison.OrdinalIgnoreCase);
+    }
+}