Refactor tests to avoid warnings

dotnet test was outputting expected errors as warnings

Author: ltrzesniewski

src/Abc.Zebus.MessageDsl.Tool.Tests/ToolTests.cs

@@ -7,35 +7,28 @@ namespace Abc.Zebus.MessageDsl.Tool.Tests;
 [TestFixture]
 public class ToolTests
 {
-    private TextWriter _originalOut = null!;
-    private TextReader _originalIn = null!;
+#pragma warning disable NUnit1032
+    private StringReader _input = null!;
     private StringWriter _output = null!;
+    private StringWriter _errorOutput = null!;
+#pragma warning restore NUnit1032
 
     [SetUp]
-    public void Setup()
+    public void SetUp()
     {
-        _originalOut = Console.Out;
-        _originalIn = Console.In;
+        _input = new StringReader("");
         _output = new StringWriter();
-        Console.SetOut(_output);
-    }
-
-    [TearDown]
-    public void TearDown()
-    {
-        Console.SetOut(_originalOut);
-        Console.SetIn(_originalIn);
-
-        _output?.Dispose();
+        _errorOutput = new StringWriter();
     }
 
     [Test]
     public void should_generate_csharp_with_namespace()
     {
-        Console.SetIn(new StringReader("TestMessage()"));
+        _input = new StringReader("TestMessage()");
 
-        var exitCode = Program.Main(["--namespace", "TestNS", "--format", "CSharp"]);
+        var exitCode = Run(["--namespace", "TestNS", "--format", "CSharp"]);
         Assert.That(exitCode, Is.EqualTo(0));
+
         var outputString = _output.ToString();
         Assert.That(outputString, Does.Contain("namespace TestNS"));
         Assert.That(outputString, Does.Contain("class TestMessage"));
@@ -49,8 +42,9 @@ public void should_generate_proto_output_with_empty_namespace_when_not_provided(
         {
             File.WriteAllText(tempFile, "TestMessage()");
 
-            var exitCode = Program.Main([tempFile, "--format", "Proto"]);
+            var exitCode = Run([tempFile, "--format", "Proto"]);
             Assert.That(exitCode, Is.EqualTo(0));
+
             var outputString = _output.ToString();
             Assert.That(outputString.Contains("message TestMessage"));
         }
@@ -63,23 +57,26 @@ public void should_generate_proto_output_with_empty_namespace_when_not_provided(
     [Test]
     public void should_error_on_file_not_found()
     {
-        var exitCode = Program.Main(["invalid_file.msg"]);
+        var exitCode = Run(["invalid_file.msg"]);
         Assert.That(exitCode, Is.EqualTo(1));
     }
 
     [Test]
     public void should_error_on_directory()
     {
         var aDirectory = Environment.CurrentDirectory;
-        var exitCode = Program.Main([aDirectory]);
+        var exitCode = Run([aDirectory]);
         Assert.That(exitCode, Is.EqualTo(1));
     }
 
     [Test]
     public void should_error_on_invalid_msg()
     {
-        Console.SetIn(new StringReader("InvalidSyntax"));
-        var exitCode = Program.Main([]);
+        _input = new StringReader("InvalidSyntax");
+        var exitCode = Run([]);
         Assert.That(exitCode, Is.EqualTo(1));
     }
+
+    private int Run(string[] args)
+        => Program.Run(args, _input, _output, _errorOutput);
 }

src/Abc.Zebus.MessageDsl.Tool/Program.cs

@@ -9,6 +9,9 @@ namespace Abc.Zebus.MessageDsl.Tool;
 public static class Program
 {
     public static int Main(string[] args)
+        => Run(args, Console.In, Console.Out, Console.Error);
+
+    public static int Run(string[] args, TextReader input, TextWriter output, TextWriter errorOutput)
     {
         var mainCommand = new RootCommand();
         var path = new Argument<string?>(".msg file", "The .msg file to process.")
@@ -23,38 +26,38 @@ public static int Main(string[] args)
         mainCommand.AddOption(defaultNamespace);
         mainCommand.AddOption(outputType);
 
-        mainCommand.SetHandler(
-            context =>
+        mainCommand.SetHandler(context =>
             {
                 var parse = context.ParseResult;
                 var parsedPath = parse.GetValueForArgument(path);
                 var parsedNamespace = parse.GetValueForOption(defaultNamespace);
                 var parsedFormat = parse.GetValueForOption(outputType);
+
                 string? txt = null;
+
                 try
                 {
                     if (parsedPath != null)
                         txt = File.ReadAllText(parsedPath);
                 }
                 catch (FileNotFoundException)
                 {
-                    Console.Error.WriteLine($"File {parsedPath} does not exist.");
+                    errorOutput.WriteLine($"File {parsedPath} does not exist.");
                     context.ExitCode = 1;
                     return;
                 }
                 catch (Exception ex)
                 {
-                    Console.Error.WriteLine($"Error reading file {parsedPath}: {ex.Message}");
+                    errorOutput.WriteLine($"Error reading file {parsedPath}: {ex.Message}");
                     context.ExitCode = 1;
                     return;
                 }
 
-                txt ??= Console.In.ReadToEnd();
+                txt ??= input.ReadToEnd();
                 var parsed = ParsedContracts.Parse(txt, parsedNamespace);
+
                 foreach (var error in parsed.Errors)
-                {
-                    Console.Error.WriteLine(error);
-                }
+                    errorOutput.WriteLine(error);
 
                 if (parsed.Errors.Count != 0)
                 {
@@ -63,24 +66,24 @@ public static int Main(string[] args)
                 }
 
                 foreach (var message in parsed.Messages)
-                {
                     message.Options.Proto = true;
-                }
 
                 switch (parsedFormat)
                 {
                     case Format.CSharp:
                     {
                         var cs = CSharpGenerator.Generate(parsed);
-                        Console.Write(cs);
+                        output.Write(cs);
                         return;
                     }
+
                     case Format.Proto:
                     {
                         var proto = ProtoGenerator.Generate(parsed);
-                        Console.Write(proto);
+                        output.Write(proto);
                         return;
                     }
+
                     default:
                         throw new InvalidOperationException();
                 }