Add main application configuration component.

mjcheetham · mjcheetham · commit c763ca00ab05 · 2019-09-09T14:25:02.000+01:00
Add main application configuration component, which will ensure the
exectuable is on the PATH (on Windows) and configure itself and Git's
credential helper in the user's config.
diff --git a/src/shared/Microsoft.Git.CredentialManager.Tests/ApplicationTests.cs b/src/shared/Microsoft.Git.CredentialManager.Tests/ApplicationTests.cs
@@ -0,0 +1,216 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.Git.CredentialManager.Tests.Objects;
+using Moq;
+using Xunit;
+
+namespace Microsoft.Git.CredentialManager.Tests
+{
+    public class ApplicationTests
+    {
+        #region Common configuration tests
+
+        [Fact]
+        public async Task Application_ConfigureAsync_HelperSet_DoesNothing()
+        {
+            const string emptyHelper = "";
+            const string gcmConfigName = "manager-core";
+            const string executablePath = "/usr/local/share/gcm-core/git-credential-manager-core";
+            string key = $"{Constants.GitConfiguration.Credential.SectionName}.{Constants.GitConfiguration.Credential.Helper}";
+
+            IConfigurableComponent application = new Application(new TestCommandContext(), executablePath);
+
+            var environment = new Mock<IEnvironment>();
+
+            var config = new TestGitConfiguration();
+            config.Dictionary[key] = new List<string>
+            {
+                emptyHelper, gcmConfigName
+            };
+
+            await application.ConfigureAsync(
+                environment.Object, EnvironmentVariableTarget.User,
+                config, GitConfigurationLevel.Global);
+
+            Assert.Single(config.Dictionary);
+            Assert.True(config.Dictionary.TryGetValue(key, out var actualValues));
+            Assert.Equal(2, actualValues.Count);
+            Assert.Equal(emptyHelper, actualValues[0]);
+            Assert.Equal(gcmConfigName, actualValues[1]);
+        }
+
+        [Fact]
+        public async Task Application_ConfigureAsync_HelperSetWithOthersPreceding_DoesNothing()
+        {
+            const string emptyHelper = "";
+            const string gcmConfigName = "manager-core";
+            const string executablePath = "/usr/local/share/gcm-core/git-credential-manager-core";
+            string key = $"{Constants.GitConfiguration.Credential.SectionName}.{Constants.GitConfiguration.Credential.Helper}";
+
+            IConfigurableComponent application = new Application(new TestCommandContext(), executablePath);
+
+            var environment = new Mock<IEnvironment>();
+
+            var config = new TestGitConfiguration();
+            config.Dictionary[key] = new List<string>
+            {
+                "foo", "bar", emptyHelper, gcmConfigName
+            };
+
+            await application.ConfigureAsync(
+                environment.Object, EnvironmentVariableTarget.User,
+                config, GitConfigurationLevel.Global);
+
+            Assert.Single(config.Dictionary);
+            Assert.True(config.Dictionary.TryGetValue(key, out var actualValues));
+            Assert.Equal(4, actualValues.Count);
+            Assert.Equal("foo", actualValues[0]);
+            Assert.Equal("bar", actualValues[1]);
+            Assert.Equal(emptyHelper, actualValues[2]);
+            Assert.Equal(gcmConfigName, actualValues[3]);
+        }
+
+        [Fact]
+        public async Task Application_ConfigureAsync_HelperSetWithOthersFollowing_ClearsEntriesSetsHelper()
+        {
+            const string emptyHelper = "";
+            const string gcmConfigName = "manager-core";
+            const string executablePath = "/usr/local/share/gcm-core/git-credential-manager-core";
+            string key = $"{Constants.GitConfiguration.Credential.SectionName}.{Constants.GitConfiguration.Credential.Helper}";
+
+            IConfigurableComponent application = new Application(new TestCommandContext(), executablePath);
+
+            var environment = new Mock<IEnvironment>();
+
+            var config = new TestGitConfiguration();
+            config.Dictionary[key] = new List<string>
+            {
+                "bar", emptyHelper, executablePath, "foo"
+            };
+
+            await application.ConfigureAsync(
+                environment.Object, EnvironmentVariableTarget.User,
+                config, GitConfigurationLevel.Global);
+
+            Assert.Single(config.Dictionary);
+            Assert.True(config.Dictionary.TryGetValue(key, out var actualValues));
+            Assert.Equal(2, actualValues.Count);
+            Assert.Equal(emptyHelper, actualValues[0]);
+            Assert.Equal(gcmConfigName, actualValues[1]);
+        }
+
+        [Fact]
+        public async Task Application_ConfigureAsync_HelperNotSet_SetsHelper()
+        {
+            const string emptyHelper = "";
+            const string gcmConfigName = "manager-core";
+            const string executablePath = "/usr/local/share/gcm-core/git-credential-manager-core";
+            string key = $"{Constants.GitConfiguration.Credential.SectionName}.{Constants.GitConfiguration.Credential.Helper}";
+
+            IConfigurableComponent application = new Application(new TestCommandContext(), executablePath);
+
+            var environment = new Mock<IEnvironment>();
+
+            var config = new TestGitConfiguration();
+
+            await application.ConfigureAsync(
+                environment.Object, EnvironmentVariableTarget.User,
+                config, GitConfigurationLevel.Global);
+
+            Assert.Single(config.Dictionary);
+            Assert.True(config.Dictionary.TryGetValue(key, out var actualValues));
+            Assert.Equal(2, actualValues.Count);
+            Assert.Equal(emptyHelper, actualValues[0]);
+            Assert.Equal(gcmConfigName, actualValues[1]);
+        }
+
+        [Fact]
+        public async Task Application_UnconfigureAsync_HelperSet_RemovesEntries()
+        {
+            const string emptyHelper = "";
+            const string gcmConfigName = "manager-core";
+            const string executablePath = "/usr/local/share/gcm-core/git-credential-manager-core";
+            string key = $"{Constants.GitConfiguration.Credential.SectionName}.{Constants.GitConfiguration.Credential.Helper}";
+
+            IConfigurableComponent application = new Application(new TestCommandContext(), executablePath);
+
+            var environment = new Mock<IEnvironment>();
+            var config = new TestGitConfiguration(new Dictionary<string, IList<string>>
+            {
+                [key] = new List<string> {emptyHelper, gcmConfigName}
+            });
+
+            await application.UnconfigureAsync(
+                environment.Object, EnvironmentVariableTarget.User,
+                config, GitConfigurationLevel.Global);
+
+            Assert.Empty(config.Dictionary);
+        }
+
+        #endregion
+
+        #region Windows-specific configuration tests
+
+        [PlatformFact(Platform.Windows)]
+        public async Task Application_ConfigureAsync_User_PathSet_DoesNothing()
+        {
+            const string executablePath = "/usr/local/share/gcm-core/git-credential-manager-core";
+
+            IConfigurableComponent application = new Application(new TestCommandContext(), executablePath);
+
+            var environment = new Mock<IEnvironment>();
+            environment.Setup(x => x.IsDirectoryOnPath("/usr/local/share/gcm-core")).Returns(true);
+
+            var config = new TestGitConfiguration();
+
+            await application.ConfigureAsync(
+                environment.Object, EnvironmentVariableTarget.User,
+                config, GitConfigurationLevel.Global);
+
+            environment.Verify(x => x.AddDirectoryToPath(It.IsAny<string>(), It.IsAny<EnvironmentVariableTarget>()), Times.Never);
+        }
+
+        [PlatformFact(Platform.Windows)]
+        public async Task Application_ConfigureAsync_User_PathNotSet_SetsUserPath()
+        {
+            const string executablePath = "/usr/local/share/gcm-core/git-credential-manager-core";
+
+            IConfigurableComponent application = new Application(new TestCommandContext(), executablePath);
+
+            var environment = new Mock<IEnvironment>();
+            environment.Setup(x => x.IsDirectoryOnPath("/usr/local/share/gcm-core")).Returns(false);
+
+            var config = new TestGitConfiguration();
+
+            await application.ConfigureAsync(
+                environment.Object, EnvironmentVariableTarget.User,
+                config, GitConfigurationLevel.Global);
+
+            environment.Verify(x => x.AddDirectoryToPath(directoryPath, EnvironmentVariableTarget.User), Times.Once);
+        }
+
+        [PlatformFact(Platform.Windows)]
+        public async Task Application_UnconfigureAsync_User_PathSet_RemovesFromUserPath()
+        {
+            const string executablePath = "/usr/local/share/gcm-core/git-credential-manager-core";
+
+            IConfigurableComponent application = new Application(new TestCommandContext(), executablePath);
+
+            var environment = new Mock<IEnvironment>();
+            environment.Setup(x => x.IsDirectoryOnPath("/usr/local/share/gcm-core")).Returns(true);
+
+            var config = new TestGitConfiguration();
+
+            await application.UnconfigureAsync(
+                environment.Object, EnvironmentVariableTarget.User,
+                config, GitConfigurationLevel.Global);
+
+            environment.Verify(x => x.RemoveDirectoryFromPath(directoryPath, EnvironmentVariableTarget.User), Times.Once);
+        }
+
+        #endregion
+    }
+}
diff --git a/src/shared/Microsoft.Git.CredentialManager/Application.cs b/src/shared/Microsoft.Git.CredentialManager/Application.cs
@@ -1,29 +1,52 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 using System;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using Microsoft.Git.CredentialManager.Commands;
 using Microsoft.Git.CredentialManager.Interop;
 
 namespace Microsoft.Git.CredentialManager
 {
-    public class Application : ApplicationBase
+    public class Application : ApplicationBase, IConfigurableComponent
     {
         private readonly string _appPath;
         private readonly IHostProviderRegistry _providerRegistry;
+        private readonly IConfigurationService _configurationService;
 
         public Application(ICommandContext context, string appPath)
+            : this(context, new HostProviderRegistry(context), new ConfigurationService(context), appPath)
+        {
+        }
+
+        internal Application(ICommandContext context,
+                             IHostProviderRegistry providerRegistry,
+                             IConfigurationService configurationService,
+                             string appPath)
             : base(context)
         {
+            EnsureArgument.NotNull(providerRegistry, nameof(providerRegistry));
+            EnsureArgument.NotNull(configurationService, nameof(configurationService));
             EnsureArgument.NotNullOrWhiteSpace(appPath, nameof(appPath));
 
             _appPath = appPath;
-            _providerRegistry = new HostProviderRegistry(context);
+            _providerRegistry = providerRegistry;
+            _configurationService = configurationService;
+
+            _configurationService.AddComponent(this);
         }
 
         public void RegisterProviders(params IHostProvider[] providers)
         {
             _providerRegistry.Register(providers);
+
+            // Add any providers that are also configurable components to the configuration service
+            foreach (IConfigurableComponent configurableProvider in providers.OfType<IConfigurableComponent>())
+            {
+                _configurationService.AddComponent(configurableProvider);
+            }
         }
 
         protected override async Task<int> RunInternalAsync(string[] args)
@@ -36,6 +59,8 @@ protected override async Task<int> RunInternalAsync(string[] args)
                 new GetCommand(_providerRegistry),
                 new StoreCommand(_providerRegistry),
                 new EraseCommand(_providerRegistry),
+                new ConfigureCommand(_configurationService),
+                new UnconfigureCommand(_configurationService),
                 new VersionCommand(),
                 new HelpCommand(appName),
             };
@@ -111,5 +136,114 @@ protected bool WriteException(Exception ex)
 
             return true;
         }
+
+        #region IConfigurableComponent
+
+        string IConfigurableComponent.Name => "Git Credential Manager";
+
+        Task IConfigurableComponent.ConfigureAsync(
+            IEnvironment environment, EnvironmentVariableTarget environmentTarget,
+            IGitConfiguration configuration, GitConfigurationLevel configurationLevel)
+        {
+            // NOTE: We currently only update the PATH in Windows installations and leave putting the GCM executable
+            //       on the PATH on other platform to their installers.
+            if (PlatformUtils.IsWindows())
+            {
+                string directoryPath = Path.GetDirectoryName(_appPath);
+                if (!environment.IsDirectoryOnPath(directoryPath))
+                {
+                    Context.Trace.WriteLine("Adding application to PATH...");
+                    environment.AddDirectoryToPath(directoryPath, environmentTarget);
+                }
+                else
+                {
+                    Context.Trace.WriteLine("Application is already on the PATH.");
+                }
+            }
+
+            string helperKey = $"{Constants.GitConfiguration.Credential.SectionName}.{Constants.GitConfiguration.Credential.Helper}";
+            string gitConfigAppName = GetGitConfigAppName();
+
+            using (IGitConfiguration targetConfig = configuration.GetFilteredConfiguration(configurationLevel))
+            {
+                /*
+                 * We are looking for the following to be considered already set:
+                 *
+                 * [credential]
+                 *     ...                         # any number of helper entries
+                 *     helper =                    # an empty value to reset/clear any previous entries
+                 *     helper = {gitConfigAppName} # the expected executable value in the last position & directly following the empty value
+                 *
+                 */
+
+                string[] currentValues = targetConfig.GetMultivarValue(helperKey, Constants.RegexPatterns.Any).ToArray();
+                if (currentValues.Length < 2 ||
+                    !string.IsNullOrWhiteSpace(currentValues[currentValues.Length - 2]) ||    // second to last entry is empty
+                    currentValues[currentValues.Length - 1] != gitConfigAppName)              // last entry is the expected executable
+                {
+                    Context.Trace.WriteLine("Updating Git credential helper configuration...");
+
+                    // Clear any existing entries in the configuration.
+                    targetConfig.DeleteMultivarEntry(helperKey, Constants.RegexPatterns.Any);
+
+                    // Add an empty value for `credential.helper`, which has the effect of clearing any helper value
+                    // from any lower-level Git configuration, then add a second value which is the actual executable path.
+                    targetConfig.SetValue(helperKey, string.Empty);
+                    targetConfig.SetMultivarValue(helperKey, Constants.RegexPatterns.None, gitConfigAppName);
+                }
+                else
+                {
+                    Context.Trace.WriteLine("Credential helper configuration is already set correctly.");
+                }
+            }
+
+            return Task.CompletedTask;
+        }
+
+        Task IConfigurableComponent.UnconfigureAsync(
+            IEnvironment environment, EnvironmentVariableTarget environmentTarget,
+            IGitConfiguration configuration, GitConfigurationLevel configurationLevel)
+        {
+            string helperKey = $"{Constants.GitConfiguration.Credential.SectionName}.{Constants.GitConfiguration.Credential.Helper}";
+            string gitConfigAppName = GetGitConfigAppName();
+
+            using (IGitConfiguration targetConfig = configuration.GetFilteredConfiguration(configurationLevel))
+            {
+                Context.Trace.WriteLine("Removing Git credential helper configuration...");
+
+                // Clear any blank 'reset' entries
+                targetConfig.DeleteMultivarEntry(helperKey, Constants.RegexPatterns.Empty);
+
+                // Clear GCM executable entries
+                targetConfig.DeleteMultivarEntry(helperKey, Regex.Escape(gitConfigAppName));
+            }
+
+            // NOTE: We currently only update the PATH in Windows installations and leave removing the GCM executable
+            //       on the PATH on other platform to their installers.
+            // Remove GCM executable from the PATH
+            if (PlatformUtils.IsWindows())
+            {
+                Context.Trace.WriteLine("Removing application from the PATH...");
+                string directoryPath = Path.GetDirectoryName(_appPath);
+                environment.RemoveDirectoryFromPath(directoryPath, environmentTarget);
+            }
+
+            return Task.CompletedTask;
+        }
+
+        private string GetGitConfigAppName()
+        {
+            const string gitCredentialPrefix = "git-credential-";
+
+            string appName = Path.GetFileNameWithoutExtension(_appPath);
+            if (appName != null && appName.StartsWith(gitCredentialPrefix, StringComparison.OrdinalIgnoreCase))
+            {
+                return appName.Substring(gitCredentialPrefix.Length);
+            }
+
+            return _appPath;
+        }
+
+        #endregion
     }
 }
diff --git a/src/shared/Microsoft.Git.CredentialManager/Constants.cs b/src/shared/Microsoft.Git.CredentialManager/Constants.cs
