Add integration style tests

Author: xt0rted

global.json

@@ -13,6 +13,11 @@
     "test:31": "dotnet r test -- --framework netcoreapp3.1",
     "test:5": "dotnet r test -- --framework net5.0",
     "test:6": "dotnet r test -- --framework net6.0",
+
+    "testbase": "dotnet test --no-build --logger \"trx;LogFilePrefix=tests\" --results-directory \"./.coverage\"",
+    "test:unit": "dotnet r testbase -- --filter \"category=unit\"",
+    "test:int": "dotnet r testbase -- --filter \"category=integration\"",
+
     "pack": "dotnet pack --no-build --output \"./artifacts\"",
 
     "build:release": "dotnet r build -- --configuration Release",

src/CommandBuilder.cs

@@ -11,19 +11,22 @@ internal class CommandBuilder
     private readonly IEnvironment _environment;
     private readonly Project _project;
     private readonly string _workingDirectory;
+    private readonly bool _captureOutput;
 
     public CommandBuilder(
         IConsoleWriter writer,
         IEnvironment environment,
         Project project,
-        string workingDirectory)
+        string workingDirectory,
+        bool captureOutput)
     {
         if (string.IsNullOrEmpty(workingDirectory)) throw new ArgumentException($"'{nameof(workingDirectory)}' cannot be null or empty.", nameof(workingDirectory));
 
         _writer = writer ?? throw new ArgumentNullException(nameof(writer));
         _environment = environment ?? throw new ArgumentNullException(nameof(environment));
         _project = project ?? throw new ArgumentNullException(nameof(project));
         _workingDirectory = workingDirectory;
+        _captureOutput = captureOutput;
     }
 
     public ProcessContext? ProcessContext { get; private set; }
@@ -44,6 +47,7 @@ public ICommandGroupRunner CreateGroupRunner(CancellationToken cancellationToken
             _environment,
             _project.Scripts!,
             ProcessContext!,
+            _captureOutput,
             cancellationToken);
 
     /// <summary>

src/CommandGroupRunner.cs

@@ -8,26 +8,30 @@ internal class CommandGroupRunner : ICommandGroupRunner
     private readonly IEnvironment _environment;
     private readonly IDictionary<string, string?> _scripts;
     private readonly ProcessContext _processContext;
+    private readonly bool _captureOutput;
     private readonly CancellationToken _cancellationToken;
 
     public CommandGroupRunner(
         IConsoleWriter writer,
         IEnvironment environment,
         IDictionary<string, string?> scripts,
         ProcessContext processContext,
+        bool captureOutput,
         CancellationToken cancellationToken)
     {
         _writer = writer ?? throw new ArgumentNullException(nameof(writer));
         _environment = environment ?? throw new ArgumentNullException(nameof(environment));
         _scripts = scripts ?? throw new ArgumentNullException(nameof(scripts));
         _processContext = processContext ?? throw new ArgumentNullException(nameof(processContext));
+        _captureOutput = captureOutput;
         _cancellationToken = cancellationToken;
     }
 
     public virtual ICommandRunner BuildCommand()
         => new CommandRunner(
             _writer,
             _processContext,
+            _captureOutput,
             _cancellationToken);
 
     public async Task<int> RunAsync(string name, string[]? scriptArgs)

src/CommandRunner.cs

@@ -6,15 +6,18 @@ internal class CommandRunner : ICommandRunner
 {
     private readonly IConsoleWriter _writer;
     private readonly ProcessContext _processContext;
+    private readonly bool _captureOutput;
     private readonly CancellationToken _cancellationToken;
 
     public CommandRunner(
         IConsoleWriter writer,
         ProcessContext processContext,
+        bool captureOutput,
         CancellationToken cancellationToken)
     {
         _writer = writer ?? throw new ArgumentNullException(nameof(writer));
         _processContext = processContext ?? throw new ArgumentNullException(nameof(processContext));
+        _captureOutput = captureOutput;
         _cancellationToken = cancellationToken;
     }
 
@@ -23,14 +26,26 @@ public async Task<int> RunAsync(string name, string cmd, string[]? args)
         _cancellationToken.ThrowIfCancellationRequested();
 
         _writer.Banner(name, ArgumentBuilder.ConcatinateCommandAndArgArrayForDisplay(cmd, args));
-        _writer.LineVerbose("Using shell: {0}", _processContext.Shell);
-        _writer.BlankLineVerbose();
 
         using (var process = new Process())
         {
             process.StartInfo.WorkingDirectory = _processContext.WorkingDirectory;
             process.StartInfo.FileName = _processContext.Shell;
 
+            StreamForwarder? outStream = null;
+            StreamForwarder? errStream = null;
+            Task? taskOut = null;
+            Task? taskErr = null;
+
+            if (_captureOutput)
+            {
+                process.StartInfo.RedirectStandardOutput = true;
+                process.StartInfo.RedirectStandardError = true;
+
+                outStream = new StreamForwarder().Capture();
+                errStream = new StreamForwarder().Capture();
+            }
+
             if (_processContext.IsCmd)
             {
                 process.StartInfo.Arguments = string.Concat(
@@ -46,13 +61,22 @@ public async Task<int> RunAsync(string name, string cmd, string[]? args)
 
             process.Start();
 
-#if NET5_0_OR_GREATER
+            if (_captureOutput)
+            {
+                taskOut = outStream!.BeginReadAsync(process.StandardOutput);
+                taskErr = errStream!.BeginReadAsync(process.StandardError);
+            }
+
             await process.WaitForExitAsync(_cancellationToken);
-#else
-            await Task.CompletedTask;
 
-            process.WaitForExit();
-#endif
+            if (_captureOutput)
+            {
+                await taskOut!.WaitAsync(_cancellationToken);
+                await taskErr!.WaitAsync(_cancellationToken);
+
+                _writer.Line(outStream!.CapturedOutput);
+                _writer.Error(errStream!.CapturedOutput);
+            }
 
             return process.ExitCode;
         }

src/Polyfills.cs

@@ -0,0 +1,27 @@
+#pragma warning disable IDE0060 // Remove unused parameter
+#pragma warning disable RCS1163 // Unused parameter.
+
+namespace RunScript;
+
+using System.Diagnostics;
+
+internal static class Polyfills
+{
+#if !NET5_0_OR_GREATER
+    public static async Task WaitForExitAsync(this Process process, CancellationToken cancellationToken)
+    {
+        await Task.CompletedTask;
+
+        process.WaitForExit();
+    }
+#endif
+
+#if !NET6_0_OR_GREATER
+    public static async Task WaitAsync(this Task task, CancellationToken cancellationToken)
+    {
+        await Task.CompletedTask;
+
+        task.Wait(cancellationToken);
+    }
+#endif
+}

src/RunScriptCommand.cs

@@ -61,7 +61,9 @@ public async Task<int> InvokeAsync(InvocationContext context)
             writer,
             _environment,
             project,
-            _workingDirectory);
+            _workingDirectory,
+            // For now we just write to the executing shell, later we can opt to write to the log instead
+            captureOutput: false);
 
         builder.SetUpEnvironment(scriptShell);
 

src/StreamForwarder.cs

@@ -0,0 +1,136 @@
+namespace RunScript;
+
+using System.Text;
+
+// https://github.com/dotnet/sdk/blob/a758a468b71e15303198506a8de1040649aa0f35/src/Cli/Microsoft.DotNet.Cli.Utils/StreamForwarder.cs
+internal sealed class StreamForwarder
+{
+    private static readonly char[] _ignoreCharacters = { '\r' };
+
+    private const char FlushBuilderCharacter = '\n';
+
+    private StringBuilder? _builder;
+#pragma warning disable IDISP006 // Implement IDisposable
+    private StringWriter? _capture;
+#pragma warning restore IDISP006 // Implement IDisposable
+    private Action<string>? _writeLine;
+    private bool _trimTrailingCapturedNewline;
+
+    public string? CapturedOutput
+    {
+        get
+        {
+            var capture = _capture?.GetStringBuilder()?.ToString();
+
+            if (_trimTrailingCapturedNewline)
+            {
+                capture = capture?.TrimEnd('\r', '\n');
+            }
+
+            return capture;
+        }
+    }
+
+    public StreamForwarder Capture(bool trimTrailingNewline = false)
+    {
+        ThrowIfCaptureSet();
+
+        _capture?.Dispose();
+        _capture = new StringWriter();
+        _trimTrailingCapturedNewline = trimTrailingNewline;
+
+        return this;
+    }
+
+    public StreamForwarder ForwardTo(Action<string> writeLine)
+    {
+        ThrowIfNull(writeLine);
+
+        ThrowIfForwarderSet();
+
+        _writeLine = writeLine;
+
+        return this;
+    }
+
+    public Task BeginReadAsync(TextReader reader)
+        => Task.Run(() => Read(reader));
+
+    public void Read(TextReader reader)
+    {
+        if (reader is null) throw new ArgumentNullException(nameof(reader));
+
+        const int bufferSize = 1;
+
+        char currentCharacter;
+
+        var buffer = new char[bufferSize];
+        _builder = new StringBuilder();
+
+        // Using Read with buffer size 1 to prevent looping endlessly
+        // like we would when using Read() with no buffer
+        while ((_ = reader.Read(buffer, 0, bufferSize)) > 0)
+        {
+            currentCharacter = buffer[0];
+
+            if (currentCharacter == FlushBuilderCharacter)
+            {
+                WriteBuilder();
+            }
+            else if (!_ignoreCharacters.Contains(currentCharacter))
+            {
+                _builder.Append(currentCharacter);
+            }
+        }
+
+        // Flush anything else when the stream is closed
+        // Which should only happen if someone used console.Write
+        if (_builder.Length > 0)
+        {
+            WriteBuilder();
+        }
+    }
+
+    private void WriteBuilder()
+    {
+        if (_builder is not null)
+        {
+            WriteLine(_builder.ToString());
+            _builder.Clear();
+        }
+    }
+
+    private void WriteLine(string str)
+    {
+        _capture?.WriteLine(str);
+
+        if (_writeLine is not null)
+        {
+            _writeLine(str);
+        }
+    }
+
+    private void ThrowIfNull(object obj)
+    {
+        if (obj is null)
+        {
+            throw new ArgumentNullException(nameof(obj));
+        }
+    }
+
+    private void ThrowIfForwarderSet()
+    {
+        if (_writeLine is not null)
+        {
+            throw new InvalidOperationException("WriteLine forwarder set previously");
+        }
+    }
+
+    private void ThrowIfCaptureSet()
+    {
+        if (_capture is not null)
+        {
+            throw new InvalidOperationException("Already capturing stream!");
+        }
+    }
+}

test/ArgumentBuilderTests.cs

@@ -1,6 +1,7 @@
 namespace RunScript;
 
 // https://github.com/dotnet/sdk/blob/09b31215867d1ffe4955fd5b7cd91eb552d3632c/src/Tests/Microsoft.DotNet.Cli.Utils.Tests/ArgumentEscaperTests.cs
+[Trait("category", "unit")]
 public class ArgumentBuilderTests
 {
     [Theory]

test/CommandBuilderTests.cs

@@ -4,6 +4,7 @@ namespace RunScript;
 using System.CommandLine.IO;
 using System.CommandLine.Rendering;
 
+[Trait("category", "unit")]
 [UsesVerify]
 public class CommandBuilderTests
 {
@@ -122,6 +123,7 @@ private static CommandBuilder SetUpTest(bool isWindows, string? comSpec = Defaul
             consoleWriter,
             environment,
             project,
-            "/test/path");
+            "/test/path",
+            captureOutput: true);
     }
 }

test/CommandGroupRunnerTests.cs

@@ -5,6 +5,7 @@ namespace RunScript;
 using System.CommandLine.Rendering;
 using System.Threading.Tasks;
 
+[Trait("category", "unit")]
 [UsesVerify]
 public class CommandGroupRunnerTests
 {
@@ -316,6 +317,7 @@ private static (TestConsole console, CommandGroupRunner groupRunner) SetUpTest(b
                     environment,
                     scripts,
                     context,
+                    true,
                     default)));
 
         return (console, groupRunner);