public void FindSecrets(Func <SecretItem, bool> comparison, List <string> expectedMatches)
        {
            List <IEnumerable <SecretItem> > secretsPages = new List <IEnumerable <SecretItem> >()
            {
                new List <SecretItem>()
                {
                    new SecretItem("https://testkeyvault.vault.azure.net/secrets/Atlanta"),
                    new SecretItem("https://testkeyvault.vault.azure.net/secrets/Seattle"),
                    new SecretItem("https://testkeyvault.vault.azure.net/secrets/NewYork"),
                    new SecretItem("https://testkeyvault.vault.azure.net/secrets/Chicago")
                },
                new List <SecretItem>()
                {
                    new SecretItem("https://testkeyvault.vault.azure.net/secrets/Portland"),
                    new SecretItem("https://testkeyvault.vault.azure.net/secrets/Austin"),
                    new SecretItem("https://testkeyvault.vault.azure.net/secrets/SanDiego"),
                    new SecretItem("https://testkeyvault.vault.azure.net/secrets/LosAngeles")
                }
            };

            var matches = KeyVaultSecretsRepository.FindSecrets(secretsPages, comparison);

            Assert.Equal(expectedMatches.Count, matches.Count);
            foreach (string name in expectedMatches)
            {
                var matchingNames = matches.Where(x => x.Identifier.Name == name);
                Assert.Equal(matchingNames.Count(), 1);
                Assert.Equal(matchingNames.First().Identifier.Name, name);
            }
        }
        public void Normalization_WorksAsExpected(string name)
        {
            string normalizedName = KeyVaultSecretsRepository.Normalize(name);
            string test           = KeyVaultSecretsRepository.Denormalize(normalizedName);

            Assert.Equal(test, name);
        }
Ejemplo n.º 3
0
            private async Task WriteSecretsKeyVaultAndUpdateSectinelFile(string functionNameOrHost, ScriptSecrets secrets, bool createSentinelFile = true)
            {
                Dictionary <string, string> dictionary = KeyVaultSecretsRepository.GetDictionaryFromScriptSecrets(secrets, functionNameOrHost);

                foreach (string key in dictionary.Keys)
                {
                    await SecretClient.SetSecretAsync(key, dictionary[key]);
                }
            }
Ejemplo n.º 4
0
            private async Task ClearAllKeyVaultSecrets()
            {
                var secretsPages = KeyVaultSecretsRepository.GetKeyVaultSecretsPagesAsync(SecretClient).AsPages();

                await foreach (Page <SecretProperties> page in secretsPages)
                {
                    foreach (SecretProperties item in page.Values)
                    {
                        await SecretClient.StartDeleteSecretAsync(item.Name);
                    }
                }
            }
Ejemplo n.º 5
0
            private async Task ClearAllKeyVaultSecrets()
            {
                var secretsPages = await KeyVaultSecretsRepository.GetKeyVaultSecretsPagesAsync(KeyVaultClient, GetKeyVaultBaseUrl());

                foreach (IPage <SecretItem> secretsPage in secretsPages)
                {
                    foreach (SecretItem item in secretsPage)
                    {
                        await KeyVaultClient.DeleteSecretAsync(GetKeyVaultBaseUrl(), item.Identifier.Name);
                    }
                }
            }
        public void FunctionKeys(string functionName, string secretName)
        {
            FunctionSecrets hostSecrets = new FunctionSecrets()
            {
                Keys = new List <Key> {
                    new Key(secretName, "test")
                }
            };

            Dictionary <string, string> dictionary = KeyVaultSecretsRepository.GetDictionaryFromScriptSecrets(hostSecrets, functionName);

            Assert.True(dictionary[$"function--{KeyVaultSecretsRepository.Normalize(functionName)}--{KeyVaultSecretsRepository.Normalize(secretName)}"] == "test");
        }
        public async Task FindSecrets(Func <SecretProperties, bool> comparison, List <string> expectedMatches)
        {
            AsyncPageable <SecretProperties> secretsPages = GetSecretProperties();
            var matches = await KeyVaultSecretsRepository.FindSecrets(secretsPages, comparison);

            Assert.Equal(expectedMatches.Count, matches.Count);
            foreach (string name in expectedMatches)
            {
                var matchingNames = matches.Where(x => x.Name == name);
                Assert.Equal(matchingNames.Count(), 1);
                Assert.Equal(matchingNames.First().Name, name);
            }
        }
        public void HostKeys(string secretName)
        {
            HostSecrets hostSecrets = new HostSecrets()
            {
                MasterKey    = new Key("master", "test"),
                FunctionKeys = new List <Key>()
                {
                    new Key(secretName, "test")
                },
                SystemKeys = new List <Key>()
                {
                    new Key(secretName, "test")
                },
            };

            Dictionary <string, string> dictionary = KeyVaultSecretsRepository.GetDictionaryFromScriptSecrets(hostSecrets, null);

            Assert.True(dictionary["host--masterKey--master"] == "test");
            Assert.True(dictionary[$"host--functionKey--{KeyVaultSecretsRepository.Normalize(secretName)}"] == "test");
            Assert.True(dictionary[$"host--systemKey--{KeyVaultSecretsRepository.Normalize(secretName)}"] == "test");
        }
Ejemplo n.º 9
0
 private string GetSecretName(string secretName)
 {
     string[] array = secretName.Split("--");
     return(KeyVaultSecretsRepository.Denormalize(array[array.Length - 1]));
 }