Inject IConsole into ValidatorRunner and add console output tests

Agent-Logs-Url: https://github.com/304NotModified/SLNX-validator/sessions/2ef89553-2469-46d8-8587-2c62c427fa11

Co-authored-by: 304NotModified <5808377+304NotModified@users.noreply.github.com>

Author: Copilot

src/SLNX-validator/IConsole.cs

@@ -0,0 +1,12 @@
+namespace JulianVerdurmen.SlnxValidator;
+
+internal interface IStandardStreamWriter
+{
+    void Write(string value);
+}
+
+internal interface IConsole
+{
+    IStandardStreamWriter Out { get; }
+    IStandardStreamWriter Error { get; }
+}

src/SLNX-validator/Program.cs

@@ -81,6 +81,7 @@ public static async Task<int> Main(string[] args)
         var services = new ServiceCollection()
             .AddSlnxValidator()
             .AddSingleton<SlnxCollector>()
+            .AddSingleton<IConsole>(new SystemConsole())
             .AddSingleton<ValidatorRunner>()
             .BuildServiceProvider();
 

src/SLNX-validator/SystemConsole.cs

@@ -0,0 +1,12 @@
+namespace JulianVerdurmen.SlnxValidator;
+
+internal sealed class SystemConsole : IConsole
+{
+    public IStandardStreamWriter Out { get; } = new ConsoleStreamWriter(Console.Out);
+    public IStandardStreamWriter Error { get; } = new ConsoleStreamWriter(Console.Error);
+
+    private sealed class ConsoleStreamWriter(TextWriter writer) : IStandardStreamWriter
+    {
+        public void Write(string value) => writer.Write(value);
+    }
+}

src/SLNX-validator/ValidatorRunner.cs

@@ -7,7 +7,7 @@
 
 namespace JulianVerdurmen.SlnxValidator;
 
-internal sealed class ValidatorRunner(SlnxCollector collector, ISonarReporter sonarReporter, ISarifReporter sarifReporter, IRequiredFilesChecker requiredFilesChecker, IFileSystem fileSystem)
+internal sealed class ValidatorRunner(SlnxCollector collector, ISonarReporter sonarReporter, ISarifReporter sarifReporter, IRequiredFilesChecker requiredFilesChecker, IFileSystem fileSystem, IConsole console)
 {
     public async Task<int> RunAsync(ValidatorRunnerOptions options, CancellationToken cancellationToken)
     {
@@ -23,7 +23,7 @@ public async Task<int> RunAsync(ValidatorRunnerOptions options, CancellationToke
 
         if (results.Count == 0)
         {
-            await Console.Error.WriteLineAsync($"No .slnx files found for input: {options.Input}");
+            console.Error.Write($"No .slnx files found for input: {options.Input}{Environment.NewLine}");
             return options.ContinueOnError ? 0 : 1;
         }
 
@@ -34,14 +34,14 @@ public async Task<int> RunAsync(ValidatorRunnerOptions options, CancellationToke
         {
             await sonarReporter.WriteReportAsync(reportResults, options.SonarqubeReportPath);
             var size = fileSystem.GetFileSize(options.SonarqubeReportPath);
-            Console.WriteLine($"SonarQube report written to: {options.SonarqubeReportPath} ({size} bytes)");
+            console.Out.Write($"SonarQube report written to: {options.SonarqubeReportPath} ({size} bytes){Environment.NewLine}");
         }
 
         if (options.SarifReportPath is not null)
         {
             await sarifReporter.WriteReportAsync(reportResults, options.SarifReportPath);
             var size = fileSystem.GetFileSize(options.SarifReportPath);
-            Console.WriteLine($"SARIF report written to: {options.SarifReportPath} ({size} bytes)");
+            console.Out.Write($"SARIF report written to: {options.SarifReportPath} ({size} bytes){Environment.NewLine}");
         }
 
         var hasErrors = results.Any(r => r.Errors.Any(e => options.SeverityOverrides.IsFailingError(e.Code)));

tests/SLNX-validator.Tests/MockFileSystem.cs

@@ -7,6 +7,7 @@ internal sealed class MockFileSystem : IFileSystem
 {
     private readonly HashSet<string> _existingPaths;
     private readonly Dictionary<string, string> _fileContents;
+    private readonly Dictionary<string, long> _fileSizes = new(StringComparer.OrdinalIgnoreCase);
 
     /// <summary>Create a mock with files that exist but have no specific content.</summary>
     public MockFileSystem(params string[] existingPaths)
@@ -34,12 +35,44 @@ public Stream CreateFile(string path)
     {
         var ms = new MemoryStream();
         CreatedFiles[path] = ms;
-        return ms;
+        return new SizeCapturingStream(ms, size => _fileSizes[path] = size);
     }
     public Stream OpenRead(string path) =>
         new MemoryStream(Encoding.UTF8.GetBytes(_fileContents.GetValueOrDefault(path, "")));
     public Task<string> ReadAllTextAsync(string path, CancellationToken cancellationToken = default) =>
         Task.FromResult(_fileContents.GetValueOrDefault(path, ""));
     public long GetFileSize(string path) =>
+        _fileSizes.TryGetValue(path, out var size) ? size :
         CreatedFiles.TryGetValue(path, out var ms) ? ms.Length : 0;
+
+    /// <summary>Captures the stream length before disposing the underlying <see cref="MemoryStream"/>.</summary>
+    private sealed class SizeCapturingStream(MemoryStream inner, Action<long> onDispose) : Stream
+    {
+        public override bool CanRead => inner.CanRead;
+        public override bool CanSeek => inner.CanSeek;
+        public override bool CanWrite => inner.CanWrite;
+        public override long Length => inner.Length;
+        public override long Position { get => inner.Position; set => inner.Position = value; }
+        public override void Flush() => inner.Flush();
+        public override int Read(byte[] buffer, int offset, int count) => inner.Read(buffer, offset, count);
+        public override long Seek(long offset, SeekOrigin origin) => inner.Seek(offset, origin);
+        public override void SetLength(long value) => inner.SetLength(value);
+        public override void Write(byte[] buffer, int offset, int count) => inner.Write(buffer, offset, count);
+        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) =>
+            inner.WriteAsync(buffer, offset, count, cancellationToken);
+        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default) =>
+            inner.WriteAsync(buffer, cancellationToken);
+        public override Task FlushAsync(CancellationToken cancellationToken) => inner.FlushAsync(cancellationToken);
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                onDispose(inner.Length);
+                inner.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+    }
 }
+

tests/SLNX-validator.Tests/TestConsole.cs

@@ -0,0 +1,21 @@
+using System.Text;
+
+namespace JulianVerdurmen.SlnxValidator.Tests;
+
+internal sealed class TestConsole : IConsole
+{
+    private readonly TestStreamWriter _out = new();
+    private readonly TestStreamWriter _error = new();
+
+    public IStandardStreamWriter Out => _out;
+    public IStandardStreamWriter Error => _error;
+
+    private sealed class TestStreamWriter : IStandardStreamWriter
+    {
+        private readonly StringBuilder _sb = new();
+
+        public void Write(string value) => _sb.Append(value);
+
+        public override string ToString() => _sb.ToString();
+    }
+}

tests/SLNX-validator.Tests/ValidatorRunnerTests.cs

@@ -9,22 +9,22 @@ namespace JulianVerdurmen.SlnxValidator.Tests;
 
 public class ValidatorRunnerTests
 {
-    private static ValidatorRunner CreateRunner(IFileSystem fileSystem, IRequiredFilesChecker? checker = null)
+    private static ValidatorRunner CreateRunner(IFileSystem fileSystem, IRequiredFilesChecker? checker = null, IConsole? console = null)
     {
         checker ??= Substitute.For<IRequiredFilesChecker>();
         var resolver = Substitute.For<ISlnxFileResolver>();
         var collector = new SlnxCollector(fileSystem, resolver, Substitute.For<ISlnxValidator>(), checker);
         var sonarReporter = new SonarReporter(fileSystem);
         var sarifReporter = new SarifReporter(fileSystem);
-        return new ValidatorRunner(collector, sonarReporter, sarifReporter, checker, fileSystem);
+        return new ValidatorRunner(collector, sonarReporter, sarifReporter, checker, fileSystem, console ?? new TestConsole());
     }
 
     private static ValidatorRunnerOptions Options(string input = "test.slnx",
         bool continueOnError = false, string? requiredFilesPattern = null) =>
         new(input, SonarqubeReportPath: null, continueOnError, requiredFilesPattern, WorkingDirectory: ".");
 
     private static ValidatorRunner CreateRunnerWithSlnx(
-        string slnxPath, string slnxContent, IRequiredFilesChecker? checker = null)
+        string slnxPath, string slnxContent, IRequiredFilesChecker? checker = null, IConsole? console = null)
     {
         checker ??= Substitute.For<IRequiredFilesChecker>();
         var fileSystem = new MockFileSystem(new Dictionary<string, string>
@@ -39,7 +39,7 @@ private static ValidatorRunner CreateRunnerWithSlnx(
         var collector = new SlnxCollector(fileSystem, resolver, validator, checker);
         var sonarReporter = new SonarReporter(fileSystem);
         var sarifReporter = new SarifReporter(fileSystem);
-        return new ValidatorRunner(collector, sonarReporter, sarifReporter, checker, fileSystem);
+        return new ValidatorRunner(collector, sonarReporter, sarifReporter, checker, fileSystem, console ?? new TestConsole());
     }
 
     #region RunAsync – file resolution
@@ -248,5 +248,58 @@ public async Task RunAsync_IgnoreAllCodesMajorSpecificCode_SpecificCodeCausesExi
     }
 
     #endregion
+
+    #region RunAsync – console output
+
+    [Test]
+    public async Task RunAsync_NoFilesFound_WritesErrorToConsole()
+    {
+        // Arrange
+        var console = new TestConsole();
+        var runner = CreateRunner(new MockFileSystem(), console: console);
+
+        // Act
+        await runner.RunAsync(Options("nonexistent.slnx"), CancellationToken.None);
+
+        // Assert
+        console.Error.ToString().Should().Contain("No .slnx files found for input: nonexistent.slnx");
+    }
+
+    [Test]
+    public async Task RunAsync_SonarqubeReportPath_WritesConfirmationToConsole()
+    {
+        // Arrange
+        var slnxPath = Path.GetFullPath("test.slnx");
+        var console = new TestConsole();
+        var runner = CreateRunnerWithSlnx(slnxPath, "<Solution />", console: console);
+        var options = new ValidatorRunnerOptions(slnxPath, SonarqubeReportPath: "report.xml",
+            ContinueOnError: false, RequiredFilesPattern: null, WorkingDirectory: ".");
+
+        // Act
+        await runner.RunAsync(options, CancellationToken.None);
+
+        // Assert
+        console.Out.ToString().Should().Contain("SonarQube report written to: report.xml");
+    }
+
+    [Test]
+    public async Task RunAsync_SarifReportPath_WritesConfirmationToConsole()
+    {
+        // Arrange
+        var slnxPath = Path.GetFullPath("test.slnx");
+        var console = new TestConsole();
+        var runner = CreateRunnerWithSlnx(slnxPath, "<Solution />", console: console);
+        var options = new ValidatorRunnerOptions(slnxPath, SonarqubeReportPath: null,
+            ContinueOnError: false, RequiredFilesPattern: null, WorkingDirectory: ".",
+            SarifReportPath: "report.sarif");
+
+        // Act
+        await runner.RunAsync(options, CancellationToken.None);
+
+        // Assert
+        console.Out.ToString().Should().Contain("SARIF report written to: report.sarif");
+    }
+
+    #endregion
 }