Add possibility to pass IAuthMethodInfo implementation to VaultOptions (#29)

Author: PaGrom

README.md

@@ -104,15 +104,30 @@ config.AddVaultConfiguration(
         "secret");
 ```
 new VaultOptions("http://localhost:8200", "root", null, null, false, 300, false, new []{'.'}),
-## Configuration using environmnt variables
+## Configuration using environment variables
 
-Alternatively, you can configure Vault connection using next environmnt variables:
+Alternatively, you can configure Vault connection using next environment variables:
 
 - `VAULT_ADDR` : Address of the Vault instance. Default value is `"http://locahost:8200`.
 - `VAULT_TOKEN` : Vault token. Used for token-based authentication. Default value is `root`.
 - `VAULT_ROLEID` : Vault AppRole ID. Used for AppRole-based authentication.
 - `VAULT_SECRET` : Vault AppRole secret. Used for AppRole-based authentication.
 
+## Configuration using IAuthMethodInfo
+
+You can configure Vault connection using any supported auth method (look at https://github.com/rajanadar/VaultSharp#auth-methods):
+
+```csharp
+config.AddVaultConfiguration(
+        () => new VaultOptions(
+            "htpp://localhost:8200",
+            new KerberosAuthMethodInfo(),
+            reloadOnChange: true,
+            reloadCheckIntervalSeconds: 60),
+        "sampleapp",
+        "secret");
+```
+
 ## Preparing secrets in Vault
 
 You need to store your secrets with special naming rules.

Source/VaultSharp.Extensions.Configuration/VaultConfigurationProvider.cs

@@ -53,7 +53,11 @@ public override void Load()
                 if (this._vaultClient == null)
                 {
                     IAuthMethodInfo authMethod;
-                    if (!string.IsNullOrEmpty(this._source.Options.VaultRoleId) &&
+                    if (this._source.Options.AuthMethod != null)
+                    {
+                        authMethod = this._source.Options.AuthMethod;
+                    }
+                    else if (!string.IsNullOrEmpty(this._source.Options.VaultRoleId) &&
                         !string.IsNullOrEmpty(this._source.Options.VaultSecret))
                     {
                         this._logger?.LogDebug("VaultConfigurationProvider: using AppRole authentication");

Source/VaultSharp.Extensions.Configuration/VaultOptions.cs

@@ -2,6 +2,7 @@ namespace VaultSharp.Extensions.Configuration
 {
     using System;
     using System.Collections.Generic;
+    using VaultSharp.V1.AuthMethods;
 
     /// <summary>
     /// Vault options class.
@@ -42,6 +43,39 @@ public VaultOptions(
             this.Namespace = @namespace;
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VaultOptions"/> class.
+        /// </summary>
+        /// <param name="vaultAddress">Vault address.</param>
+        /// <param name="authMethod">Vault auth method.</param>
+        /// <param name="reloadOnChange">Reload secrets if changed in Vault.</param>
+        /// <param name="reloadCheckIntervalSeconds">Interval in seconds to check Vault for any changes.</param>
+        /// <param name="omitVaultKeyName">Omit Vault Key Name in Configuration Keys.</param>
+        /// <param name="additionalCharactersForConfigurationPath">Additional characters for the Configuration path.</param>
+        /// <param name="namespace">Vault namespace.</param>
+        public VaultOptions(
+            string vaultAddress,
+            IAuthMethodInfo authMethod,
+            bool reloadOnChange = false,
+            int reloadCheckIntervalSeconds = 300,
+            bool omitVaultKeyName = false,
+            IEnumerable<char>? additionalCharactersForConfigurationPath = null,
+            string? @namespace = null)
+        {
+            this.VaultAddress = vaultAddress;
+            this.AuthMethod = authMethod;
+            this.ReloadOnChange = reloadOnChange;
+            this.ReloadCheckIntervalSeconds = reloadCheckIntervalSeconds;
+            this.OmitVaultKeyName = omitVaultKeyName;
+            this.AdditionalCharactersForConfigurationPath = additionalCharactersForConfigurationPath ?? Array.Empty<char>();
+            this.Namespace = @namespace;
+        }
+
+        /// <summary>
+        /// Gets Vault Auth method
+        /// </summary>
+        public IAuthMethodInfo? AuthMethod { get; }
+
         /// <summary>
         /// Gets Vault URL address.
         /// </summary>

Tests/VaultSharp.Extensions.Configuration.Test/IntegrationTests.cs

@@ -358,6 +358,39 @@ public async Task Success_WatcherTest_OmitVaultKey_TokenAuth()
                 await container.DisposeAsync().ConfigureAwait(false);
             }
         }
+
+        [Fact]
+        public async Task Success_AuthMethod()
+        {
+            // arrange
+            using CancellationTokenSource cts = new CancellationTokenSource();
+            string jsonData = @"{""option1"": ""value1"",""subsection"":{""option2"": ""value2""}}";
+
+            var container = this.PrepareVaultContainer();
+            try
+            {
+                await container.StartAsync(cts.Token).ConfigureAwait(false);
+                await this.LoadDataAsync("myservice-config", jsonData).ConfigureAwait(false);
+
+                // act
+                ConfigurationBuilder builder = new ConfigurationBuilder();
+                builder.AddVaultConfiguration(
+                    () => new VaultOptions("http://localhost:8200", new TokenAuthMethodInfo("root"), reloadOnChange: true, reloadCheckIntervalSeconds: 10, omitVaultKeyName: true),
+                    "myservice-config",
+                    "secret",
+                    this._logger);
+                var configurationRoot = builder.Build();
+
+                // assert
+                configurationRoot.GetValue<string>("option1").Should().Be("value1");
+                configurationRoot.GetSection("subsection").GetValue<string>("option2").Should().Be("value2");
+            }
+            finally
+            {
+                cts.Cancel();
+                await container.DisposeAsync().ConfigureAwait(false);
+            }
+        }
     }
 
     public class TestConfigObject