Added tests to bring code coverage to 100%. Added codecov badge.

Author: gowon

README.md

@@ -1,9 +1,10 @@
 # SecureStore.Contrib.Configuration
 
-A [SecureStore](https://github.com/neosmart/SecureStore) configuration provider to use with .NET Core's `Microsoft.Extensions.Configuration`.
-
 [![Nuget (with prereleases)](https://img.shields.io/nuget/vpre/SecureStore.Contrib.Configuration?color=blue)](https://www.nuget.org/packages/SecureStore.Contrib.Configuration)
 ![build](https://github.com/gowon/SecureStore.Contrib.Configuration/workflows/build/badge.svg)
+[![codecov](https://codecov.io/gh/gowon/SecureStore.Contrib.Configuration/branch/master/graph/badge.svg)](https://codecov.io/gh/gowon/SecureStore.Contrib.Configuration)
+
+A [SecureStore](https://github.com/neosmart/SecureStore) configuration provider to use with .NET Core's `Microsoft.Extensions.Configuration`.
 
 ## Installing via NuGet
 

src/SecureStore.Contrib.Configuration/SecureStoreConfigurationExtensions.cs

@@ -10,13 +10,13 @@ public static class SecureStoreConfigurationExtensions
         public static IConfigurationBuilder AddSecureStoreFile(this IConfigurationBuilder builder, string path,
             string key, KeyType keyType)
         {
-            return AddSecureStoreFile(builder, null, path, key, keyType, false, false);
+            return AddSecureStoreFile(builder, path, key, keyType, false);
         }
 
         public static IConfigurationBuilder AddSecureStoreFile(this IConfigurationBuilder builder, string path,
             string key, KeyType keyType, bool optional)
         {
-            return AddSecureStoreFile(builder, null, path, key, keyType, optional, false);
+            return AddSecureStoreFile(builder, path, key, keyType, optional, false);
         }
 
         public static IConfigurationBuilder AddSecureStoreFile(this IConfigurationBuilder builder, string path,
@@ -42,7 +42,7 @@ public static IConfigurationBuilder AddSecureStoreFile(this IConfigurationBuilde
 
             if (string.IsNullOrEmpty(key))
             {
-                throw new ArgumentException("File path must be a non-empty string.", nameof(key));
+                throw new ArgumentException("File key/path must be a non-empty string.", nameof(key));
             }
 
             if (provider == null && Path.IsPathRooted(path))

src/SecureStore.Contrib.Configuration/SecureStoreConfigurationProvider.cs

@@ -27,7 +27,7 @@ public override void Load(Stream stream)
                         manager.LoadKeyFromPassword(source.Key);
                         break;
                     default:
-                        throw new ArgumentOutOfRangeException();
+                        throw new ArgumentOutOfRangeException(nameof(source.KeyType));
                 }
 
                 foreach (var key in manager.Keys)

test/SecureStore.Contrib.Configuration.Tests/SecureStore.Contrib.Configuration.Tests.csproj

@@ -7,8 +7,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Configuration" Version="3.1.1" />
-    <PackageReference Include="Microsoft.Extensions.FileProviders.Abstractions" Version="3.1.1" />
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="3.1.2" />
+    <PackageReference Include="Microsoft.Extensions.FileProviders.Abstractions" Version="3.1.2" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
     <PackageReference Include="SecureStore" Version="1.0.3" />
     <PackageReference Include="xunit" Version="2.4.1" />

test/SecureStore.Contrib.Configuration.Tests/SecureStoreConfigurationExtensionsTests.cs

@@ -7,6 +7,19 @@ namespace SecureStore.Contrib.Configuration.Tests
 
     public class SecureStoreConfigurationExtensionsTests
     {
+        [Fact]
+        public void AddSecureStoreFile_ThrowsIfBuilderIsNull()
+        {
+            // Arrange
+            var path = "does-not-exist.json";
+            var key = "password";
+
+            // Act and Assert
+            var ex = Assert.Throws<ArgumentNullException>(() =>
+                SecureStoreConfigurationExtensions.AddSecureStoreFile(null, path, key, KeyType.Password).Build());
+            Assert.StartsWith("builder", ex.ParamName);
+        }
+
         [Theory]
         [InlineData(null)]
         [InlineData("")]
@@ -36,7 +49,7 @@ public void AddSecureStoreFile_ThrowsIfKeyIsNullOrEmpty(string key)
             var ex = Assert.Throws<ArgumentException>(() =>
                 configurationBuilder.AddSecureStoreFile(path, key, KeyType.Password));
             Assert.Equal("key", ex.ParamName);
-            Assert.StartsWith("File path must be a non-empty string.", ex.Message);
+            Assert.StartsWith("File key/path must be a non-empty string.", ex.Message);
         }
 
         [Fact]
@@ -64,6 +77,9 @@ public void AddSecureStoreFile_ThrowsIfFileDoesNotExistAtKey()
             var ex = Assert.Throws<FileNotFoundException>(() =>
                 new ConfigurationBuilder().AddSecureStoreFile(path, keyPath, KeyType.File).Build());
             Assert.StartsWith($"Could not find file ", ex.Message);
+
+            // Cleanup
+            File.Delete(path);
         }
     }
 }

test/SecureStore.Contrib.Configuration.Tests/SecureStoreConfigurationProviderTests.cs

@@ -0,0 +1,112 @@
+namespace SecureStore.Contrib.Configuration.Tests
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using NeoSmart.SecureStore;
+    using Xunit;
+
+    public class SecureStoreConfigurationProviderTests
+    {
+        private static string Password => "P@$$w0rD!";
+
+        private static readonly Dictionary<string, string> SecureData = new Dictionary<string, string>
+        {
+            {"foo1", "bar1"},
+            {"foo2", "bar2"},
+            {"foo3", "bar3"}
+        };
+
+        private void CreateTestStore(string storePath, string key, KeyType type)
+        {
+            using (var sman = SecretsManager.CreateStore())
+            {
+                if (type == KeyType.Password)
+                {
+                    sman.LoadKeyFromPassword(key);
+                }
+                else
+                {
+                    sman.GenerateKey();
+                }
+
+                foreach (var secretKey in SecureData.Keys)
+                {
+                    sman.Set(secretKey, SecureData[secretKey]);
+                }
+
+                sman.SaveStore(storePath);
+                sman.ExportKey(key);
+            }
+        }
+
+        [Fact]
+        public void LoadStreamUsingKeyFile()
+        {
+            var storePath = Path.GetTempFileName();
+            var keyPath = Path.GetTempFileName();
+
+            CreateTestStore(storePath, keyPath, KeyType.File);
+
+            var provider = new SecureStoreConfigurationProvider(new SecureStoreConfigurationSource
+            {
+                KeyType = KeyType.File,
+                Key = keyPath,
+                Optional = true
+            });
+
+            using (var stream = new FileStream(storePath, FileMode.Open, FileAccess.Read))
+            {
+                provider.Load(stream);
+            }
+
+            File.Delete(storePath);
+            File.Delete(keyPath);
+        }
+
+        [Fact]
+        public void LoadStreamUsingPassword()
+        {
+            var storePath = Path.GetTempFileName();
+            CreateTestStore(storePath, Password, KeyType.Password);
+
+            var provider = new SecureStoreConfigurationProvider(new SecureStoreConfigurationSource
+            {
+                KeyType = KeyType.Password,
+                Key = Password,
+                Optional = true
+            });
+
+            using (var stream = new FileStream(storePath, FileMode.Open, FileAccess.Read))
+            {
+                provider.Load(stream);
+            }
+
+            File.Delete(storePath);
+        }
+
+        [Fact]
+        public void LoadStreamUsingPassword_ThrowsIfKeyTypeNotInRange()
+        {
+            var storePath = Path.GetTempFileName();
+            CreateTestStore(storePath, Password, KeyType.Password);
+
+            var source = new SecureStoreConfigurationSource
+            {
+                KeyType = (KeyType) 3,
+                Key = Password,
+                Optional = true
+            };
+            var provider = new SecureStoreConfigurationProvider(source);
+
+            using (var stream = new FileStream(storePath, FileMode.Open, FileAccess.Read))
+            {
+                var ex = Assert.Throws<ArgumentOutOfRangeException>(() =>
+                    provider.Load(stream));
+                Assert.Equal(nameof(source.KeyType), ex.ParamName);
+            }
+
+            File.Delete(storePath);
+        }
+    }
+}