(cake-buildGH-3947) Add Command aliases

* fixes cake-build#3947

src/Cake.Common.Tests/Fixtures/Tools/Command/CommandRunnerFixture.cs

@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+using Cake.Common.Tools.Command;
+using Cake.Core.IO;
+using Cake.Testing.Fixtures;
+
+namespace Cake.Common.Tests.Fixtures.Tools.Command
+{
+    internal class CommandRunnerFixture : ToolFixture<CommandSettings>
+    {
+        public ProcessArgumentBuilder Arguments { get; set; }
+
+        public string ToolName
+        {
+            get => Settings.ToolName;
+            set => Settings.ToolName = value;
+        }
+
+        public ICollection<string> ToolExecutableNames
+        {
+            get => Settings.ToolExecutableNames;
+            set => Settings.ToolExecutableNames = value;
+        }
+
+        public CommandRunnerFixture()
+           : base("dotnet.exe")
+        {
+            Arguments = new ProcessArgumentBuilder();
+            Settings.ToolName = "dotnet";
+            Settings.ToolExecutableNames = new[] { "dotnet.exe", "dotnet" };
+        }
+
+        protected override void RunTool()
+        {
+            GetRunner().RunCommand(Arguments);
+        }
+
+        protected CommandRunner GetRunner()
+            => new CommandRunner(
+                            Settings,
+                            FileSystem,
+                            Environment,
+                            ProcessRunner,
+                            Tools);
+    }
+}

src/Cake.Common.Tests/Fixtures/Tools/Command/CommandRunnerStandardErrorFixture.cs

@@ -0,0 +1,14 @@
+namespace Cake.Common.Tests.Fixtures.Tools.Command
+{
+    internal class CommandRunnerStandardErrorFixture : CommandRunnerStandardOutputFixture
+    {
+        public string StandardError { get; private set; }
+
+        protected override void RunTool()
+        {
+            ExitCode = GetRunner().RunCommand(Arguments, out var standardOutput, out var standardError);
+            StandardOutput = standardOutput;
+            StandardError = standardError;
+        }
+    }
+}

src/Cake.Common.Tests/Fixtures/Tools/Command/CommandRunnerStandardOutFixture.cs

@@ -0,0 +1,14 @@
+namespace Cake.Common.Tests.Fixtures.Tools.Command
+{
+    internal class CommandRunnerStandardOutputFixture : CommandRunnerFixture
+    {
+        public int ExitCode { get; protected set; }
+        public string StandardOutput { get; protected set; }
+
+        protected override void RunTool()
+        {
+            ExitCode = GetRunner().RunCommand(Arguments, out var standardOutput);
+            StandardOutput = standardOutput;
+        }
+    }
+}

src/Cake.Common.Tests/Fixtures/Tools/Command/CommandRunnerStandardOutputFixtureExtentions.cs

@@ -0,0 +1,19 @@
+namespace Cake.Common.Tests.Fixtures.Tools.Command
+{
+    internal static class CommandRunnerStandardOutputFixtureExtentions
+    {
+        public static T GivenStandardOutput<T>(this T fixture, params string[] standardOutput)
+           where T : CommandRunnerStandardOutputFixture
+        {
+            fixture.ProcessRunner.Process.SetStandardOutput(standardOutput);
+            return fixture;
+        }
+
+        public static T GivenStandardError<T>(this T fixture, params string[] standardOutput)
+           where T : CommandRunnerStandardOutputFixture
+        {
+            fixture.ProcessRunner.Process.SetStandardError(standardOutput);
+            return fixture;
+        }
+    }
+}

src/Cake.Common.Tests/Unit/Tools/Command/CommandRunnerTests.cs

@@ -0,0 +1,203 @@
+using System;
+using Cake.Common.Tests.Fixtures.Tools.Command;
+using Xunit;
+
+namespace Cake.Common.Tests.Unit.Tools.Command
+{
+    public sealed class CommandRunnerTests
+    {
+        public sealed class TheRunCommandMethod
+        {
+            [Fact]
+            public void Should_Throw_If_Arguments_Was_Null()
+            {
+                // Given
+                var fixture = new CommandRunnerFixture
+                {
+                    Arguments = null
+                };
+
+                // When
+                var result = Record.Exception(() => fixture.Run());
+
+                // Then
+                AssertEx.IsArgumentNullException(result, "arguments");
+            }
+
+            [Fact]
+            public void Should_Throw_If_Settings_Was_Null()
+            {
+                // Given
+                var fixture = new CommandRunnerFixture
+                {
+                    Settings = null
+                };
+
+                // When
+                var result = Record.Exception(() => fixture.Run());
+
+                // Then
+                AssertEx.IsArgumentNullException(result, "settings");
+            }
+
+            [Fact]
+            public void Should_Throw_If_ToolName_Was_Null()
+            {
+                // Given
+                var fixture = new CommandRunnerFixture
+                {
+                    ToolName = null
+                };
+
+                // When
+                var result = Record.Exception(() => fixture.Run());
+
+                // Then
+                AssertEx.IsArgumentNullException(result, "ToolName");
+            }
+        }
+
+        [Fact]
+        public void Should_Throw_If_ToolExecutableNames_Was_Null()
+        {
+            // Given
+            var fixture = new CommandRunnerFixture
+            {
+                ToolExecutableNames = null
+            };
+
+            // When
+            var result = Record.Exception(() => fixture.Run());
+
+            // Then
+            AssertEx.IsArgumentNullException(result, "ToolExecutableNames");
+        }
+
+        [Fact]
+        public void Should_Throw_If_ToolExecutableNames_Was_Empty()
+        {
+            // Given
+            var fixture = new CommandRunnerFixture
+            {
+                ToolExecutableNames = Array.Empty<string>()
+            };
+
+            // When
+            var result = Record.Exception(() => fixture.Run());
+
+            // Then
+            AssertEx.IsArgumentNullException(result, "ToolExecutableNames");
+        }
+
+        [Fact]
+        public void Should_Call_Settings_PostAction()
+        {
+            // Given
+            var called = false;
+            var fixture = new CommandRunnerFixture
+            {
+                Settings = { PostAction = _ => called = true }
+            };
+
+            // When
+            var result = fixture.Run();
+
+            // Then
+            Assert.True(called, "Settings PostAction not called");
+        }
+
+        [Fact]
+        public void Should_Return_StandardOutput()
+        {
+            // Given
+            const string expectStandard = "LINE1";
+            const int expectExitCode = 0;
+
+            var fixture = new CommandRunnerStandardOutputFixture()
+                            .GivenStandardOutput(expectStandard);
+
+            // When
+            fixture.Run();
+
+            // Then
+            Assert.Equal(expectStandard, fixture.StandardOutput);
+            Assert.Equal(expectExitCode, fixture.ExitCode);
+        }
+
+        [Fact]
+        public void Should_Return_StandardOutput_ExitCode()
+        {
+            // Given
+            const string expectStandard = "LINE1";
+            const int expectExitCode = 1337;
+
+            var fixture = new CommandRunnerStandardOutputFixture
+                            {
+                                Settings =
+                                                {
+                                                    HandleExitCode = exitCode => exitCode == expectExitCode
+                                                }
+                            }
+                            .GivenStandardOutput(expectStandard);
+
+            fixture.ProcessRunner.Process.SetExitCode(expectExitCode);
+
+            // When
+            fixture.Run();
+
+            // Then
+            Assert.Equal(expectStandard, fixture.StandardOutput);
+            Assert.Equal(expectExitCode, fixture.ExitCode);
+        }
+
+        [Fact]
+        public void Should_Return_StandardError()
+        {
+            // Given
+            const string expectStandard = "LINE1";
+            const string expectError = "ERRORLINE1";
+            const int expectExitCode = 0;
+
+            var fixture = new CommandRunnerStandardErrorFixture()
+                            .GivenStandardError(expectError)
+                            .GivenStandardOutput(expectStandard);
+
+            // When
+            fixture.Run();
+
+            // Then
+            Assert.Equal(expectStandard, fixture.StandardOutput);
+            Assert.Equal(expectError, fixture.StandardError);
+            Assert.Equal(expectExitCode, fixture.ExitCode);
+        }
+
+        [Fact]
+        public void Should_Return_StandardError_ExitCode()
+        {
+            // Given
+            const string expectStandard = "LINE1";
+            const string expectError = "ERRORLINE1";
+            const int expectExitCode = 1337;
+
+            var fixture = new CommandRunnerStandardErrorFixture
+                            {
+                                Settings =
+                                {
+                                    HandleExitCode = exitCode => exitCode == expectExitCode
+                                }
+                            }
+                            .GivenStandardError(expectError)
+                            .GivenStandardOutput(expectStandard);
+
+            fixture.ProcessRunner.Process.SetExitCode(expectExitCode);
+
+            // When
+            fixture.Run();
+
+            // Then
+            Assert.Equal(expectStandard, fixture.StandardOutput);
+            Assert.Equal(expectError, fixture.StandardError);
+            Assert.Equal(expectExitCode, fixture.ExitCode);
+        }
+    }
+}