Refactor to static and simplify

Author: liliankasem

src/Cli/func/Helpers/DotnetHelpers.cs

@@ -30,7 +30,7 @@ public static void EnsureDotnet()
         {
             try
             {
-                _ = new DotnetMuxer().MuxerPath;
+                _ = DotnetMuxer.GetMuxerPath();
             }
             catch (InvalidOperationException ex)
             {

src/Cli/func/Helpers/DotnetMuxer.cs

@@ -1,82 +1,61 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
-// Copied from: https://github.com/dotnet/sdk/blob/main/src/Cli/Microsoft.DotNet.Cli.Utils/Muxer.cs
+// Adapted from: https://github.com/dotnet/sdk/blob/main/src/Cli/Microsoft.DotNet.Cli.Utils/Muxer.cs
 using System.Runtime.InteropServices;
 
 namespace Azure.Functions.Cli.Helpers;
 
-public class DotnetMuxer
+internal static class DotnetMuxer
 {
-    public static readonly string MuxerName = "dotnet";
-
-    private readonly string _muxerPath;
-
-    public static readonly string ExeSuffix = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? ".exe" : string.Empty;
-
-    public DotnetMuxer()
+    private static readonly string _muxerName = "dotnet";
+    private static readonly string _exeSuffix = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? ".exe" : string.Empty;
+
+    /// <summary>
+    /// Locates the dotnet muxer (dotnet executable).
+    /// </summary>
+    /// <returns>The full path to the dotnet executable.</returns>
+    /// <exception cref="InvalidOperationException">Thrown when the dotnet executable cannot be located.</exception>
+    public static string GetMuxerPath()
     {
+        string muxerPath;
+
         // Most scenarios are running dotnet.dll as the app
         // Root directory with muxer should be two above app base: <root>/sdk/<version>
         string rootPath = Path.GetDirectoryName(Path.GetDirectoryName(AppContext.BaseDirectory.TrimEnd(Path.DirectorySeparatorChar)));
         if (rootPath is not null)
         {
-            string muxerPathMaybe = Path.Combine(rootPath, $"{MuxerName}{FileNameSuffixes.CurrentPlatform.Exe}");
-            if (File.Exists(muxerPathMaybe))
+            muxerPath = Path.Combine(rootPath, $"{_muxerName}{_exeSuffix}");
+            if (File.Exists(muxerPath))
             {
-                _muxerPath = muxerPathMaybe;
+                return muxerPath;
             }
         }
 
-        if (_muxerPath is null)
-        {
-            // Best-effort search for muxer.
-            string processPath = Environment.ProcessPath;
+        // Best-effort search for muxer.
+        muxerPath = Environment.ProcessPath;
 
-            // The current process should be dotnet in most normal scenarios except when dotnet.dll is loaded in a custom host like the testhost
-            if (processPath is not null && !Path.GetFileNameWithoutExtension(processPath).Equals("dotnet", StringComparison.OrdinalIgnoreCase))
+        // The current process should be dotnet in most normal scenarios except when dotnet.dll is loaded in a custom host like the testhost
+        if (muxerPath is not null && !Path.GetFileNameWithoutExtension(muxerPath).Equals("dotnet", StringComparison.OrdinalIgnoreCase))
+        {
+            // SDK sets DOTNET_HOST_PATH as absolute path to current dotnet executable
+            muxerPath = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH");
+            if (muxerPath is null)
             {
-                // SDK sets DOTNET_HOST_PATH as absolute path to current dotnet executable
-                processPath = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH");
-                if (processPath is null)
+                // fallback to DOTNET_ROOT which typically holds some dotnet executable
+                string root = Environment.GetEnvironmentVariable("DOTNET_ROOT");
+                if (root is not null)
                 {
-                    // fallback to DOTNET_ROOT which typically holds some dotnet executable
-                    var root = Environment.GetEnvironmentVariable("DOTNET_ROOT");
-                    if (root is not null)
-                    {
-                        processPath = Path.Combine(root, $"dotnet{ExeSuffix}");
-                    }
+                    muxerPath = Path.Combine(root, $"dotnet{_exeSuffix}");
                 }
             }
-
-            _muxerPath = processPath;
         }
-    }
 
-    internal string SharedFxVersion
-    {
-        get
+        if (muxerPath is null)
         {
-            var depsFile = new FileInfo(GetDataFromAppDomain("FX_DEPS_FILE") ?? string.Empty);
-            return depsFile.Directory?.Name ?? string.Empty;
+            throw new InvalidOperationException("Unable to locate dotnet multiplexer");
         }
-    }
 
-    public string MuxerPath
-    {
-        get
-        {
-            if (_muxerPath == null)
-            {
-                throw new InvalidOperationException("Unable to locate dotnet multiplexer");
-            }
-
-            return _muxerPath;
-        }
-    }
-
-    public static string GetDataFromAppDomain(string propertyName)
-    {
-        return AppContext.GetData(propertyName) as string;
+        return muxerPath;
     }
 }

src/Cli/func/Helpers/FileNameSuffixes.cs

@@ -9,86 +9,68 @@ namespace Azure.Functions.Cli.UnitTests.HelperTests
     public class DotnetMuxerTests
     {
         [Fact]
-        public void DotnetMuxer_FindsMuxerPath_WhenDotnetExists()
+        public void GetMuxerPath_ReturnsMuxerPath_WhenDotnetExists()
         {
-            // Arrange & Act
-            var muxer = new DotnetMuxer();
+            // Act
+            var path = DotnetMuxer.GetMuxerPath();
 
             // Assert
-            Assert.NotNull(muxer.MuxerPath);
-            Assert.False(string.IsNullOrWhiteSpace(muxer.MuxerPath));
+            Assert.NotNull(path);
+            Assert.False(string.IsNullOrWhiteSpace(path));
         }
 
         [Fact]
-        public void MuxerPath_ThrowsInvalidOperationException_WhenNotFound()
+        public void GetMuxerPath_ContainsDotnetExecutable()
         {
-            // This test is tricky because DotnetMuxer's constructor tries to find dotnet
-            // In a normal test environment, dotnet will be found
-            // We can only test the property behavior
-            var muxer = new DotnetMuxer();
-
-            // If we got here, dotnet was found (which is expected in test environment)
-            Assert.NotNull(muxer.MuxerPath);
-        }
+            // Act
+            var path = DotnetMuxer.GetMuxerPath();
 
-        [Fact]
-        public void MuxerName_IsCorrect()
-        {
             // Assert
-            Assert.Equal("dotnet", DotnetMuxer.MuxerName);
-        }
-
-        [Fact]
-        public void ExeSuffix_IsCorrectForPlatform()
-        {
-            // Act & Assert
-            if (OperatingSystem.IsWindows())
-            {
-                Assert.Equal(".exe", DotnetMuxer.ExeSuffix);
-            }
-            else
-            {
-                Assert.Equal(string.Empty, DotnetMuxer.ExeSuffix);
-            }
+            Assert.Contains("dotnet", path, StringComparison.OrdinalIgnoreCase);
         }
 
         [Fact]
-        public void GetDataFromAppDomain_ReturnsNull_ForNonExistentKey()
+        public void GetMuxerPath_PointsToExecutableFile()
         {
             // Act
-            var result = DotnetMuxer.GetDataFromAppDomain("NON_EXISTENT_KEY_12345");
+            var path = DotnetMuxer.GetMuxerPath();
 
             // Assert
-            Assert.Null(result);
+            // The path should exist as a file
+            Assert.True(
+                File.Exists(path) || File.Exists(path + ".exe"),
+                $"Expected muxer path '{path}' to exist");
         }
 
         [Fact]
-        public void MuxerPath_ContainsDotnetExecutable()
+        public void GetMuxerPath_PointsToFunctionalDotnetExecutable()
         {
-            // Arrange
-            var muxer = new DotnetMuxer();
-
             // Act
-            var path = muxer.MuxerPath;
+            var path = DotnetMuxer.GetMuxerPath();
 
-            // Assert
-            Assert.Contains("dotnet", path, StringComparison.OrdinalIgnoreCase);
-        }
+            // Assert - invoke dotnet --version to verify it's functional
+            var startInfo = new System.Diagnostics.ProcessStartInfo
+            {
+                FileName = path,
+                Arguments = "--version",
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                UseShellExecute = false,
+                CreateNoWindow = true
+            };
 
-        [Fact]
-        public void MuxerPath_PointsToExecutableFile()
-        {
-            // Arrange
-            var muxer = new DotnetMuxer();
+            using var process = System.Diagnostics.Process.Start(startInfo);
+            Assert.NotNull(process);
 
-            // Act
-            var path = muxer.MuxerPath;
+            var output = process.StandardOutput.ReadToEnd();
+            process.WaitForExit();
 
             // Assert
-            // The path should exist as a file
-            Assert.True(
-                File.Exists(path) || File.Exists(path + ".exe"),
-                $"Expected muxer path '{path}' to exist");
+            Assert.Equal(0, process.ExitCode);
+            Assert.False(string.IsNullOrWhiteSpace(output), "Expected dotnet --version to produce output");
+
+            // Verify output looks like a version number (e.g., "8.0.100")
+            Assert.Matches(@"^\d+\.\d+\.\d+", output.Trim());
         }
     }
 }