Exemple #1
0
 public sealed override void LoadConfiguration()
 {
     _configuration = Git.Configuration.ReadConfiuration(Environment.CurrentDirectory, UseConfigLocal, UseConfigSystem);
 }
Exemple #2
0
 public void LoadConfiguration()
 {
     _configuration = new Git.Configuration(Environment.CurrentDirectory, UseConfigLocal, UseConfigSystem);
 }
        public void LoadOperationArgumentsTest()
        {
            var program = new Program
            {
                _dieException = (Program caller, Exception e, string path, int line, string name) => Assert.False(true, $"Error: {e.ToString()}"),
                _dieMessage   = (Program caller, string m, string path, int line, string name) => Assert.False(true, $"Error: {m}"),
                _exit         = (Program caller, int e, string m, string path, int line, string name) => Assert.False(true, $"Error: {e} {m}")
            };

            var configs = new Dictionary <Git.ConfigurationLevel, Dictionary <string, string> >
            {
                {
                    Git.ConfigurationLevel.Local,
                    new Dictionary <string, string>(Program.ConfigKeyComparer)
                    {
                        { "credential.validate", "true" },
                        { "credential.useHttpPath", "true" },
                        { "credential.not-match.com.useHttpPath", "false" },
                    }
                },
                {
                    Git.ConfigurationLevel.Global,
                    new Dictionary <string, string>(Program.ConfigKeyComparer)
                    {
                        { "credential.validate", "false" },
                        { "credential.vstsScope", "vso.build,vso.code_write" },
                    }
                },
                {
                    Git.ConfigurationLevel.Xdg,
                    new Dictionary <string, string>(Program.ConfigKeyComparer)
                    {
                    }
                },
                {
                    Git.ConfigurationLevel.System,
                    new Dictionary <string, string>(Program.ConfigKeyComparer)
                    {
                    }
                },
                {
                    Git.ConfigurationLevel.Portable,
                    new Dictionary <string, string>(Program.ConfigKeyComparer)
                    {
                    }
                },
            };
            var envvars = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
            {
                { "HOME", Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) },
            };
            var gitconfig = new Git.Configuration(configs);
            var targetUri = new Authentication.TargetUri("https://example.visualstudio.com/");

            var opargsMock = new Mock <OperationArguments>();

            opargsMock.Setup(o => o.EnvironmentVariables)
            .Returns(envvars);
            opargsMock.Setup(o => o.GitConfiguration)
            .Returns(gitconfig);
            opargsMock.Setup(o => o.TargetUri)
            .Returns(targetUri);
            opargsMock.Setup(o => o.QueryUri)
            .Returns(targetUri);
            opargsMock.SetupProperty(o => o.UseHttpPath);
            opargsMock.SetupProperty(o => o.ValidateCredentials);
            opargsMock.SetupProperty(o => o.VstsTokenScope);

            var opargs = opargsMock.Object;

            program.LoadOperationArguments(opargs);

            Assert.NotNull(opargs);
            Assert.True(opargs.ValidateCredentials, "credential.validate");
            Assert.True(opargs.UseHttpPath, "credential.useHttpPath");

            Assert.NotNull(opargs.VstsTokenScope);

            var expectedScope = Authentication.VstsTokenScope.BuildAccess | Authentication.VstsTokenScope.CodeWrite;

            Assert.Equal(expectedScope, opargs.VstsTokenScope);
        }
        public void TryReadStringTest(int keyValue, string configValue, string environValue, string expectedValue)
        {
            KeyType key = (KeyType)keyValue;

            var program = new Program
            {
                _dieException = (Program caller, Exception e, string path, int line, string name) => Assert.False(true, $"Error: {e.ToString()}"),
                _dieMessage   = (Program caller, string m, string path, int line, string name) => Assert.False(true, $"Error: {m}"),
                _exit         = (Program caller, int e, string m, string path, int line, string name) => Assert.False(true, $"Error: {e} {m}")
            };

            Assert.True(program.EnvironmentKeys.ContainsKey(key));

            var configs = new Dictionary <Git.ConfigurationLevel, Dictionary <string, string> >
            {
                { Git.ConfigurationLevel.Local, new Dictionary <string, string>(Program.ConfigKeyComparer) },
                { Git.ConfigurationLevel.Global, new Dictionary <string, string>(Program.ConfigKeyComparer) },
                { Git.ConfigurationLevel.Xdg, new Dictionary <string, string>(Program.ConfigKeyComparer) },
                { Git.ConfigurationLevel.System, new Dictionary <string, string>(Program.ConfigKeyComparer) },
                { Git.ConfigurationLevel.Portable, new Dictionary <string, string>(Program.ConfigKeyComparer) },
            };
            var envvars = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
            {
                { "HOME", Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) },
            };

            bool setupComplete = false;

            if (!string.IsNullOrEmpty(configValue) && program.ConfigurationKeys.TryGetValue(key, out string configKey))
            {
                configs[Git.ConfigurationLevel.Local].Add($"credential.{configKey}", configValue);
                setupComplete = true;
            }

            if (!string.IsNullOrEmpty(environValue) && program.EnvironmentKeys.TryGetValue(key, out string environKey))
            {
                envvars.Add(environKey, environValue);
                setupComplete = true;
            }

            if (!setupComplete)
            {
                return;
            }

            var gitconfig = new Git.Configuration(configs);
            var targetUri = new Authentication.TargetUri("https://example.visualstudio.com/");

            var opargsMock = new Mock <OperationArguments>();

            opargsMock.Setup(v => v.EnvironmentVariables)
            .Returns(envvars);
            opargsMock.Setup(v => v.GitConfiguration)
            .Returns(gitconfig);
            opargsMock.Setup(v => v.TargetUri)
            .Returns(targetUri);
            opargsMock.Setup(v => v.QueryUri)
            .Returns(targetUri);

            if (expectedValue != null)
            {
                Assert.True(CommonFunctions.TryReadString(program, opargsMock.Object, key, out string actualValue));
                Assert.Equal(expectedValue, actualValue);
            }
            else
            {
                Assert.False(CommonFunctions.TryReadString(program, opargsMock.Object, key, out string actualValue));
                Assert.Null(actualValue);
            }
        }
 public void LoadConfiguration()
 {
     _configuration = new Git.Configuration(Environment.CurrentDirectory, UseConfigLocal, UseConfigSystem);
 }
Exemple #6
0
 public virtual void LoadConfiguration()
 {
     _configuration = Git.Configuration.ReadConfiuration(Environment.CurrentDirectory, UseConfigLocal, UseConfigSystem);
 }