Close #32 Searching for a file on the system path

MedallionShell.Tests/GeneralTest.cs

@@ -17,6 +17,53 @@ namespace Medallion.Shell.Tests
 
     public class GeneralTest
     {
+        [Platform("Win", Reason = "Tests Windows-specific executables")]
+        [TestCase("dotnet", @"C:\Program Files\dotnet\dotnet.exe")]
+        [TestCase("dotnet.exe", @"C:\Program Files\dotnet\dotnet.exe")]
+        [TestCase("where.exe", @"C:\Windows\System32\where.exe")]
+        [TestCase("cmd", @"C:\Windows\System32\cmd.exe")]
+        [TestCase("cmd.exe", @"C:\Windows\System32\cmd.exe")]
+        [TestCase("powershell.exe", @"C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe")]
+        [TestCase("explorer.exe", @"C:\Windows\explorer.exe")]
+        [TestCase("git.exe", @"C:\Program Files\Git\cmd\git.exe")]
+        [TestCase("does.not.exist", null)]
+        // echo is not a program on Windows but an internal command in cmd.exe or powershell.exe.
+        // However, things like git may still install echo (e.g. C:\Program Files\Git\usr\bin\echo.EXE)
+        // so there's no guarantee for echo on Windows.
+        public void TestGetFullPathOnWindows(string executable, string? expected)
+        {
+            StringAssert.AreEqualIgnoringCase(expected, Shell.GetFullPathUsingSystemPathOrDefault(executable));
+            var command = Command.Run("where", executable);
+            command.StandardOutput.ReadToEnd().Trim().ShouldEqual(
+                expected ?? string.Empty,
+                $"Exit code: {command.Result.ExitCode}, StdErr: '{command.Result.StandardError}'");
+        }
+
+        [Platform("Unix", Reason = "Tests Unix-specific executables")]
+        [TestCase("dotnet", "/usr/bin/dotnet")]
+        [TestCase("which", "/usr/bin/which")]
+        [TestCase("head", "/usr/bin/head")]
+        [TestCase("sh", "/bin/sh")]
+        [TestCase("ls", "/bin/ls")]
+        [TestCase("grep", "/bin/grep")]
+        [TestCase("sleep", "/bin/sleep")]
+        [TestCase("echo", "/bin/echo")]
+        [TestCase("does.not.exist", null)]
+        public void TestGetFullPathOnLinux(string executable, string? expected)
+        {
+            Shell.GetFullPathUsingSystemPathOrDefault(executable).ShouldEqual(expected);
+            var command = Command.Run("which", executable);
+            command.StandardOutput.ReadToEnd().Trim().ShouldEqual(
+                expected ?? string.Empty,
+                $"Exit code: {command.Result.ExitCode}, StdErr: '{command.Result.StandardError}'");
+        }
+
+        [Test]
+        public void TestCommandWithoutFullyQualifiedPath()
+        {
+            Assert.That(TestShell.Run("git", "--version").StandardOutput.ReadToEnd(), Does.StartWith("git version"));
+        }
+
         [Test]
         public void TestGrep()
         {

MedallionShell/Shell.cs

@@ -4,7 +4,9 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
+using System.IO;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -36,12 +38,17 @@ public Command Run(string executable, IEnumerable<object>? arguments = null, Act
         {
             Throw.If(string.IsNullOrEmpty(executable), "executable is required");
 
+            var executablePath = !executable.Contains(Path.DirectorySeparatorChar)
+                && GetFullPathUsingSystemPathOrDefault(executable) is { } fullPath
+                ? fullPath
+                : executable;
+
             var finalOptions = this.GetOptions(options);
 
             var processStartInfo = new ProcessStartInfo
             {
                 CreateNoWindow = true,
-                FileName = executable,
+                FileName = executablePath,
                 RedirectStandardError = true,
                 RedirectStandardInput = true,
                 RedirectStandardOutput = true,
@@ -76,6 +83,24 @@ public Command Run(string executable, IEnumerable<object>? arguments = null, Act
             return command;
         }
 
+        // internal for testing
+        internal static string? GetFullPathUsingSystemPathOrDefault(string executable)
+        {
+            var paths = Environment.GetEnvironmentVariable("PATH")!.Split(Path.PathSeparator);
+
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                var pathExtensions = Environment.GetEnvironmentVariable("PATHEXT")!
+                    .Split(Path.PathSeparator)
+                    .Concat(new[] { string.Empty })
+                    .ToArray();
+                return paths.SelectMany(path => pathExtensions.Select(pathExtension => Path.Combine(path, executable + pathExtension)))
+                    .FirstOrDefault(File.Exists);
+            }
+
+            return paths.Select(path => Path.Combine(path, executable)).FirstOrDefault(File.Exists);
+        }
+
         private static void PopulateArguments(ProcessStartInfo processStartInfo, IEnumerable<object?>? arguments, Options options)
         {
             if (arguments is null) { return; }