public void TestPassword()
{
CredentialParams сredential = new CredentialParams();
сredential.Password = null;
Assert.Null(сredential.Password);
сredential.Password = "******";
Assert.Equal("qwerty", сredential.Password);
}
public void TestAccessKey()
{
var сredential = new CredentialParams();
сredential.AccessKey = null;
Assert.Null(сredential.AccessKey);
сredential.AccessKey = "key";
Assert.Equal("key", сredential.AccessKey);
}
public void TestUsername()
{
var сredential = new CredentialParams();
сredential.Username = null;
Assert.Null(сredential.Username);
сredential.Username = "******";
Assert.Equal("Kate Negrienko", сredential.Username);
}
public void TestStoreKey()
{
var сredential = new CredentialParams();
сredential.StoreKey = null;
Assert.Null(сredential.StoreKey);
сredential.StoreKey = "Store key";
Assert.Equal("Store key", сredential.StoreKey);
Assert.True(сredential.UseCredentialStore);
}
/// <summary>
/// Lookups credential parameters by its key.
/// </summary>
/// <param name="correlationId">(optional) transaction id to trace execution through call chain.</param>
/// <param name="key">a key to uniquely identify the credential parameters.</param>
/// <returns>resolved credential parameters or null if nothing was found.</returns>
public async Task <CredentialParams> LookupAsync(string correlationId, string key)
{
CredentialParams credential = null;
lock (_lock)
{
_items.TryGetValue(key, out credential);
}
return(await Task.FromResult(credential));
}
/// <summary>
/// Reads credentials from configuration parameters.
/// Each section represents an individual CredentialParams
/// </summary>
/// <param name="credentials">configuration parameters to be read</param>
private void ReadCredentials(ConfigParams credentials)
{
lock (_lock)
{
_items.Clear();
foreach (var entry in credentials)
{
_items[entry.Key] = CredentialParams.FromString(entry.Value);
}
}
}
public void TestAccessKeyWithAnotherParamName()
{
var сredential = new CredentialParams();
сredential.Add("client_key", "client key");
Assert.Equal("client key", сredential.AccessKey);
сredential.Add("secret_key", "secret key");
сredential.Set("client_key", null);
Assert.Equal("secret key", сredential.AccessKey);
}
/// <summary>
/// Reads credentials from configuration parameters.
/// Each section represents an individual CredentialParams
/// </summary>
/// <param name="config">configuration parameters to be read</param>
public void ReadCredentials(ConfigParams config)
{
lock (_lock)
{
_items.Clear();
var sections = config.GetSectionNames();
foreach (var section in sections)
{
var value = config.GetSection(section);
var creadentials = CredentialParams.FromConfig(value);
_items.Add(section, creadentials);
}
}
}
/// <summary>
/// Stores credential parameters into the store.
/// </summary>
/// <param name="correlationId">(optional) transaction id to trace execution through call chain.</param>
/// <param name="key">a key to uniquely identify the credential parameters.</param>
/// <param name="credential">a credential parameters to be stored.</param>
/// <returns></returns>
public async Task StoreAsync(string correlationId, string key, CredentialParams credential)
{
lock (_lock)
{
if (credential != null)
{
_items[key] = credential;
}
else
{
_items.Remove(key);
}
}
await Task.Delay(0);
}
public async void TestLookupAndStore()
{
var config = ConfigParams.FromTuples(
"key1.username", "user1",
"key1.password", "pass1",
"key2.username", "user2",
"key2.password", "pass2"
);
var credentialStore = new MemoryCredentialStore();
credentialStore.ReadCredentials(config);
var cred1 = await credentialStore.LookupAsync("123", "key1");
var cred2 = await credentialStore.LookupAsync("123", "key2");
Assert.Equal("user1", cred1.Username);
Assert.Equal("pass1", cred1.Password);
Assert.Equal("user2", cred2.Username);
Assert.Equal("pass2", cred2.Password);
var credConfig = new CredentialParams(
ConfigParams.FromTuples(
"username", "user3",
"password", "pass3",
"access_id", "123"
));
await credentialStore.StoreAsync(null, "key3", credConfig);
var cred3 = await credentialStore.LookupAsync("123", "key3");
Assert.Equal("user3", cred3.Username);
Assert.Equal("pass3", cred3.Password);
Assert.Equal("123", cred3.AccessId);
}
/// <summary>
/// Configures component by passing configuration parameters.
/// </summary>
/// <param name="config">configuration parameters to be set.</param>
/// <param name="configAsDefault">boolean parameter for default configuration. If "true"
/// the default value will be added to the result.</param>
public void Configure(ConfigParams config, bool configAsDefault = true)
{
_credentials.AddRange(CredentialParams.ManyFromConfig(config, configAsDefault));
}
private async Task <CredentialParams> LookupInStoresAsync(string correlationId, CredentialParams credential)
{
if (credential.UseCredentialStore == false)
{
return(null);
}
var key = credential.StoreKey;
if (_references == null)
{
return(null);
}
var components = _references.GetOptional(new Descriptor("*", "credential_store", "*", "*", "*"));
if (components.Count == 0)
{
throw new ReferenceException(correlationId, "Credential store wasn't found to make lookup");
}
foreach (var component in components)
{
var store = component as ICredentialStore;
if (store != null)
{
var resolvedCredential = await store.LookupAsync(correlationId, key);
if (resolvedCredential != null)
{
return(resolvedCredential);
}
}
}
return(null);
}
/// <summary>
/// Adds a new credential to component credentials
/// </summary>
/// <param name="connection">new credential parameters to be added</param>
public void Add(CredentialParams connection)
{
_credentials.Add(connection);
}
