Remove manual home variable lookup (#46349)

kasperk81 · web-flow · commit 7d3013e998e8 · 2025-01-29T10:53:36.000+01:00
diff --git a/src/Cli/Microsoft.DotNet.Configurer/CliFolderPathCalculator.cs b/src/Cli/Microsoft.DotNet.Configurer/CliFolderPathCalculator.cs
@@ -42,8 +42,6 @@ public static string WindowsNonExpandedToolsShimPath
 
         public static string ToolsResolverCachePath => Path.Combine(DotnetUserProfileFolderPath, ToolsResolverCacheFolderName);
 
-        public static string PlatformHomeVariableName => CliFolderPathCalculatorCore.PlatformHomeVariableName;
-
         public static string DotnetHomePath
         {
             get
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/CliPathInfo.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/CliPathInfo.cs
@@ -24,7 +24,7 @@ public CliPathInfo(
                 throw new ArgumentException($"{nameof(host.Version)} of {nameof(host)} cannot be null or whitespace.", nameof(host));
             }
 
-            UserProfileDir = GetUserProfileDir(environment);
+            UserProfileDir = CliFolderPathCalculator.DotnetHomePath;
             GlobalSettingsDir = GetGlobalSettingsDir(settingsLocation);
             HostSettingsDir = Path.Combine(GlobalSettingsDir, host.HostIdentifier);
             HostVersionSettingsDir = Path.Combine(GlobalSettingsDir, host.HostIdentifier, host.Version);
@@ -38,13 +38,6 @@ public CliPathInfo(
 
         public string HostVersionSettingsDir { get; }
 
-        private static string GetUserProfileDir(IEnvironment environment) => environment.GetEnvironmentVariable(
-            RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
-                ? "USERPROFILE"
-                : "HOME")
-            ?? Environment.GetFolderPath(Environment.SpecialFolder.UserProfile)
-            ?? throw new NotSupportedException("HOME or USERPROFILE environment variable is not defined, the environment is not supported");
-
         private static string GetGlobalSettingsDir(string? settingsLocation)
         {
             var definedSettingsLocation = string.IsNullOrWhiteSpace(settingsLocation)
diff --git a/src/Cli/dotnet/SudoEnvironmentDirectoryOverride.cs b/src/Cli/dotnet/SudoEnvironmentDirectoryOverride.cs
@@ -3,6 +3,7 @@
 
 using System.CommandLine;
 using Microsoft.DotNet.Cli.Utils;
+using Microsoft.DotNet.Configurer;
 using NuGet.Common;
 using NuGet.Configuration;
 
@@ -32,8 +33,8 @@ public static void OverrideEnvironmentVariableToTmp(ParseResult parseResult)
             if (!OperatingSystem.IsWindows() && IsRunningUnderSudo() && IsRunningWorkloadCommand(parseResult))
             {
                 string sudoHome = PathUtilities.CreateTempSubdirectory();
-                var homeBeforeOverride = Path.Combine(Environment.GetEnvironmentVariable("HOME"));
-                Environment.SetEnvironmentVariable("HOME", sudoHome);
+                var homeBeforeOverride = Path.Combine(Environment.GetEnvironmentVariable(CliFolderPathCalculator.DotnetHomeVariableName));
+                Environment.SetEnvironmentVariable(CliFolderPathCalculator.DotnetHomeVariableName, sudoHome);
 
                 CopyUserNuGetConfigToOverriddenHome(homeBeforeOverride);
             }
diff --git a/src/Common/CliFolderPathCalculatorCore.cs b/src/Common/CliFolderPathCalculatorCore.cs
@@ -7,8 +7,6 @@ static class CliFolderPathCalculatorCore
     {
         public const string DotnetHomeVariableName = "DOTNET_CLI_HOME";
         public const string DotnetProfileDirectoryName = ".dotnet";
-        public static readonly string PlatformHomeVariableName =
-            RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "USERPROFILE" : "HOME";
 
         public static string? GetDotnetUserProfileFolderPath()
         {
@@ -26,14 +24,10 @@ static class CliFolderPathCalculatorCore
             var home = Environment.GetEnvironmentVariable(DotnetHomeVariableName);
             if (string.IsNullOrEmpty(home))
             {
-                home = Environment.GetEnvironmentVariable(PlatformHomeVariableName);
+                home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
                 if (string.IsNullOrEmpty(home))
                 {
-                    home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
-                    if (string.IsNullOrEmpty(home))
-                    {
-                        return null;
-                    }
+                    return null;
                 }
             }
 
diff --git a/test/Microsoft.NET.Build.Tests/GivenThatWeWantToBuildANetCoreApp.cs b/test/Microsoft.NET.Build.Tests/GivenThatWeWantToBuildANetCoreApp.cs
@@ -4,6 +4,7 @@
 #nullable disable
 
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using Microsoft.Extensions.DependencyModel;
 using Microsoft.NET.Build.Tasks;
 using Newtonsoft.Json.Linq;
@@ -167,7 +168,8 @@ private void It_targets_the_right_framework(
 
                 var additionalProbingPaths = ((JArray)devruntimeConfig["runtimeOptions"]["additionalProbingPaths"]).Values<string>();
                 // can't use Path.Combine on segments with an illegal `|` character
-                var expectedPath = $"{Path.Combine(FileConstants.UserProfileFolder, ".dotnet", "store")}{Path.DirectorySeparatorChar}|arch|{Path.DirectorySeparatorChar}|tfm|";
+                var homePath = Environment.GetEnvironmentVariable(RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "USERPROFILE" : "HOME");
+                var expectedPath = $"{Path.Combine(homePath, ".dotnet", "store")}{Path.DirectorySeparatorChar}|arch|{Path.DirectorySeparatorChar}|tfm|";
                 additionalProbingPaths.Should().Contain(expectedPath);
             }
 
@@ -269,7 +271,7 @@ public void It_runs_the_app_from_the_output_folder(string targetFramework)
         [InlineData("net7.0")]
         [InlineData(ToolsetInfo.CurrentTargetFramework)]
         public void It_runs_a_rid_specific_app_from_the_output_folder(string targetFramework)
-        {         
+        {
             RunAppFromOutputFolder("RunFromOutputFolderWithRID_" + targetFramework, true, false, targetFramework);
         }
 
@@ -1001,7 +1003,7 @@ public void It_warns_on_nonportable_rids(string targetFramework, string[] rids,
                 IsExe = true
             };
 
-            // Reference the package, add it to restore sources, and use a test-specific packages folder 
+            // Reference the package, add it to restore sources, and use a test-specific packages folder
             testProject.PackageReferences.Add(package);
             testProject.AdditionalProperties["RestoreAdditionalProjectSources"] = Path.GetDirectoryName(package.NupkgPath);
             testProject.AdditionalProperties["RestorePackagesPath"] = @"$(MSBuildProjectDirectory)\packages";
@@ -1054,7 +1056,7 @@ public void It_does_not_warn_on_rids_if_no_framework_references()
                 IsExe = true
             };
 
-            // Reference the package, add it to restore sources, and use a test-specific packages folder 
+            // Reference the package, add it to restore sources, and use a test-specific packages folder
             testProject.PackageReferences.Add(package);
             testProject.AdditionalProperties["RestoreAdditionalProjectSources"] = Path.GetDirectoryName(package.NupkgPath);
             testProject.AdditionalProperties["RestorePackagesPath"] = @"$(MSBuildProjectDirectory)\packages";
diff --git a/test/Microsoft.NET.Build.Tests/GivenThatWeWantToUseAnalyzers.cs b/test/Microsoft.NET.Build.Tests/GivenThatWeWantToUseAnalyzers.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 #nullable disable
+using Microsoft.DotNet.Configurer;
 
 namespace Microsoft.NET.Build.Tests
 {
@@ -258,7 +259,7 @@ public void It_resolves_multitargeted_analyzers()
         static readonly List<string> nugetRoots = new()
             {
                 TestContext.Current.NuGetCachePath,
-                Path.Combine(FileConstants.UserProfileFolder, ".dotnet", "NuGetFallbackFolder"),
+                Path.Combine(CliFolderPathCalculator.DotnetHomePath, ".dotnet", "NuGetFallbackFolder"),
                 Path.Combine(TestContext.Current.ToolsetUnderTest.DotNetRoot, "packs")
             };
 
diff --git a/test/Microsoft.NET.Build.Tests/Microsoft.NET.Build.Tests.csproj b/test/Microsoft.NET.Build.Tests/Microsoft.NET.Build.Tests.csproj
@@ -34,9 +34,10 @@
   <ItemGroup>
     <!-- Make sure tasks project is built, but don't directly reference it as an assembly. -->
     <ProjectReference Include="..\..\src\Tasks\Microsoft.NET.Build.Tasks\Microsoft.NET.Build.Tasks.csproj" PrivateAssets="all" ReferenceOutputAssembly="false" />
-    
+
     <ProjectReference Include="..\Microsoft.NET.TestFramework\Microsoft.NET.TestFramework.csproj" />
     <ProjectReference Include="..\TelemetryStdOutLogger\TelemetryStdOutLogger.csproj" />
+    <ProjectReference Include="..\..\src\Cli\Microsoft.DotNet.Configurer\Microsoft.DotNet.Configurer.csproj" />
   </ItemGroup>
 
   <ItemGroup>
@@ -53,5 +54,5 @@
   </ItemGroup>
 
   <Import Project="Sdk.targets" Sdk="Microsoft.NET.Sdk" />
-  
+
 </Project>
diff --git a/test/Microsoft.NET.TestFramework/FileConstants.cs b/test/Microsoft.NET.TestFramework/FileConstants.cs
@@ -9,8 +9,5 @@ public static class FileConstants
 
         public static readonly string DynamicLibSuffix = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? ".dll" :
                                                          RuntimeInformation.IsOSPlatform(OSPlatform.OSX) ? ".dylib" : ".so";
-        public static readonly string? UserProfileFolder = Environment.GetEnvironmentVariable(
-                                                                RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ?
-                                                                    "USERPROFILE" : "HOME");
     }
 }
diff --git a/test/dotnet-build.Tests/GivenDotnetBuildBuildsCsproj.cs b/test/dotnet-build.Tests/GivenDotnetBuildBuildsCsproj.cs
@@ -4,6 +4,7 @@
 #nullable disable
 
 using System.CommandLine;
+using Microsoft.DotNet.Configurer;
 
 namespace Microsoft.DotNet.Cli.Build.Tests
 {
@@ -379,7 +380,7 @@ public void It_resolves_analyzers_targeting_mulitple_roslyn_versions(string comp
         static readonly List<string> nugetRoots = new()
         {
             TestContext.Current.NuGetCachePath,
-            Path.Combine(FileConstants.UserProfileFolder, ".dotnet", "NuGetFallbackFolder")
+            Path.Combine(CliFolderPathCalculator.DotnetHomePath, ".dotnet", "NuGetFallbackFolder")
         };
 
         static string RelativeNuGetPath(string absoluteNuGetPath)
diff --git a/test/dotnet-new.Tests/DotnetNewDebugOptionsTests.cs b/test/dotnet-new.Tests/DotnetNewDebugOptionsTests.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Microsoft.DotNet.Cli.Utils;
+using Microsoft.DotNet.Configurer;
 
 namespace Microsoft.DotNet.Cli.New.IntegrationTests
 {
@@ -93,7 +94,7 @@ public Task CanShowConfigWithDebugShowConfig()
         public void DoesNotCreateCacheWhenVirtualHiveIsUsed()
         {
             string home = CreateTemporaryFolder(folderName: "Home");
-            string envVariable = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "USERPROFILE" : "HOME";
+            string envVariable = CliFolderPathCalculator.DotnetHomePath;
 
             new DotnetNewCommand(_log, "--debug:ephemeral-hive")
                .WithoutCustomHive()
diff --git a/test/dotnet.Tests/GivenThatDotNetRunsCommands.cs b/test/dotnet.Tests/GivenThatDotNetRunsCommands.cs
@@ -3,6 +3,7 @@
 
 #nullable disable
 
+using System.Runtime.InteropServices;
 using Microsoft.DotNet.Configurer;
 using LocalizableStrings = Microsoft.DotNet.Cli.Utils.LocalizableStrings;
 
@@ -39,7 +40,7 @@ public void UnresolvedPlatformReferencesFailAsExpected()
         public void GivenAMissingHomeVariableItExecutesHelpCommandSuccessfully(string value)
         {
             new DotnetCommand(Log)
-                .WithEnvironmentVariable(CliFolderPathCalculator.PlatformHomeVariableName, value)
+                .WithEnvironmentVariable(RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "USERPROFILE" : "HOME", value)
                 .WithEnvironmentVariable(CliFolderPathCalculator.DotnetHomeVariableName, "")
                 .Execute("--help")
                 .Should()
diff --git a/test/dotnet.Tests/GivenThatTheUserIsRunningDotNetForTheFirstTime.cs b/test/dotnet.Tests/GivenThatTheUserIsRunningDotNetForTheFirstTime.cs
@@ -27,14 +27,12 @@ public TestCommand Setup(ITestOutputHelper log, TestAssetsManager testAssets, [C
 
             var command = new DotnetCommand(log)
                 .WithWorkingDirectory(TestDirectory)
-                .WithEnvironmentVariable("HOME", testNuGetHome)
-                .WithEnvironmentVariable("USERPROFILE", testNuGetHome)
                 .WithEnvironmentVariable("APPDATA", testNuGetHome)
                 .WithEnvironmentVariable("DOTNET_CLI_TEST_FALLBACKFOLDER", cliTestFallbackFolder)
                 .WithEnvironmentVariable("DOTNET_CLI_TEST_LINUX_PROFILED_PATH", profiled)
                 .WithEnvironmentVariable("DOTNET_CLI_TEST_OSX_PATHSD_PATH", pathsd)
                 .WithEnvironmentVariable("SkipInvalidConfigurations", "true")
-                .WithEnvironmentVariable(CliFolderPathCalculator.DotnetHomeVariableName, "");
+                .WithEnvironmentVariable(CliFolderPathCalculator.DotnetHomeVariableName, testNuGetHome);
 
             NugetFallbackFolder = new DirectoryInfo(cliTestFallbackFolder);
             DotDotnetFolder = new DirectoryInfo(Path.Combine(testNuGetHome, ".dotnet"));
diff --git a/test/dotnet.Tests/TestCommandExtensions.cs b/test/dotnet.Tests/TestCommandExtensions.cs
@@ -7,15 +7,7 @@ public static class TestCommandExtensions
     {
         public static TestCommand WithUserProfileRoot(this TestCommand testCommand, string path)
         {
-            var userProfileEnvironmentVariableName = GetUserProfileEnvironmentVariableName();
-            return testCommand.WithEnvironmentVariable(userProfileEnvironmentVariableName, path);
-        }
-
-        private static string GetUserProfileEnvironmentVariableName()
-        {
-            return RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
-                ? "LocalAppData"
-                : "HOME";
+            return testCommand.WithEnvironmentVariable("DOTNET_CLI_HOME", path);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -42,8 +42,6 @@ public static string WindowsNonExpandedToolsShimPath`
`42`	`42`
`43`	`43`	`public static string ToolsResolverCachePath => Path.Combine(DotnetUserProfileFolderPath, ToolsResolverCacheFolderName);`
`44`	`44`
`45`		`- public static string PlatformHomeVariableName => CliFolderPathCalculatorCore.PlatformHomeVariableName;`
`46`		`-`
`47`	`45`	`public static string DotnetHomePath`
`48`	`46`	`{`
`49`	`47`	`get`
Original file line number	Diff line number	Diff line change
`@@ -7,8 +7,6 @@ static class CliFolderPathCalculatorCore`
`7`	`7`	`{`
`8`	`8`	`public const string DotnetHomeVariableName = "DOTNET_CLI_HOME";`
`9`	`9`	`public const string DotnetProfileDirectoryName = ".dotnet";`
`10`		`- public static readonly string PlatformHomeVariableName =`
`11`		`- RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "USERPROFILE" : "HOME";`
`12`	`10`
`13`	`11`	`public static string? GetDotnetUserProfileFolderPath()`
`14`	`12`	`{`
`@@ -26,14 +24,10 @@ static class CliFolderPathCalculatorCore`
`26`	`24`	`var home = Environment.GetEnvironmentVariable(DotnetHomeVariableName);`
`27`	`25`	`if (string.IsNullOrEmpty(home))`
`28`	`26`	`{`
`29`		`- home = Environment.GetEnvironmentVariable(PlatformHomeVariableName);`
	`27`	`+ home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);`
`30`	`28`	`if (string.IsNullOrEmpty(home))`
`31`	`29`	`{`
`32`		`- home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);`
`33`		`- if (string.IsNullOrEmpty(home))`
`34`		`- {`
`35`		`- return null;`
`36`		`- }`
	`30`	`+ return null;`
`37`	`31`	`}`
`38`	`32`	`}`
`39`	`33`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`// The .NET Foundation licenses this file to you under the MIT license.`
`3`	`3`
`4`	`4`	`#nullable disable`
	`5`	`+using Microsoft.DotNet.Configurer;`
`5`	`6`
`6`	`7`	`namespace Microsoft.NET.Build.Tests`
`7`	`8`	`{`
`@@ -258,7 +259,7 @@ public void It_resolves_multitargeted_analyzers()`
`258`	`259`	`static readonly List<string> nugetRoots = new()`
`259`	`260`	`{`
`260`	`261`	`TestContext.Current.NuGetCachePath,`
`261`		`- Path.Combine(FileConstants.UserProfileFolder, ".dotnet", "NuGetFallbackFolder"),`
	`262`	`+ Path.Combine(CliFolderPathCalculator.DotnetHomePath, ".dotnet", "NuGetFallbackFolder"),`
`262`	`263`	`Path.Combine(TestContext.Current.ToolsetUnderTest.DotNetRoot, "packs")`
`263`	`264`	`};`
`264`	`265`
Original file line number	Diff line number	Diff line change
`@@ -9,8 +9,5 @@ public static class FileConstants`
`9`	`9`
`10`	`10`	`public static readonly string DynamicLibSuffix = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? ".dll" :`
`11`	`11`	`RuntimeInformation.IsOSPlatform(OSPlatform.OSX) ? ".dylib" : ".so";`
`12`		`- public static readonly string? UserProfileFolder = Environment.GetEnvironmentVariable(`
`13`		`- RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ?`
`14`		`- "USERPROFILE" : "HOME");`
`15`	`12`	`}`
`16`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`#nullable disable`
`5`	`5`
`6`	`6`	`using System.CommandLine;`
	`7`	`+using Microsoft.DotNet.Configurer;`
`7`	`8`
`8`	`9`	`namespace Microsoft.DotNet.Cli.Build.Tests`
`9`	`10`	`{`
`@@ -379,7 +380,7 @@ public void It_resolves_analyzers_targeting_mulitple_roslyn_versions(string comp`
`379`	`380`	`static readonly List<string> nugetRoots = new()`
`380`	`381`	`{`
`381`	`382`	`TestContext.Current.NuGetCachePath,`
`382`		`- Path.Combine(FileConstants.UserProfileFolder, ".dotnet", "NuGetFallbackFolder")`
	`383`	`+ Path.Combine(CliFolderPathCalculator.DotnetHomePath, ".dotnet", "NuGetFallbackFolder")`
`383`	`384`	`};`
`384`	`385`
`385`	`386`	`static string RelativeNuGetPath(string absoluteNuGetPath)`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`// The .NET Foundation licenses this file to you under the MIT license.`
`3`	`3`
`4`	`4`	`using Microsoft.DotNet.Cli.Utils;`
	`5`	`+using Microsoft.DotNet.Configurer;`
`5`	`6`
`6`	`7`	`namespace Microsoft.DotNet.Cli.New.IntegrationTests`
`7`	`8`	`{`
`@@ -93,7 +94,7 @@ public Task CanShowConfigWithDebugShowConfig()`
`93`	`94`	`public void DoesNotCreateCacheWhenVirtualHiveIsUsed()`
`94`	`95`	`{`
`95`	`96`	`string home = CreateTemporaryFolder(folderName: "Home");`
`96`		`- string envVariable = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "USERPROFILE" : "HOME";`
	`97`	`+ string envVariable = CliFolderPathCalculator.DotnetHomePath;`
`97`	`98`
`98`	`99`	`new DotnetNewCommand(_log, "--debug:ephemeral-hive")`
`99`	`100`	`.WithoutCustomHive()`