public async Task CacheSecretProvider_GetSecretAsync_InvalidateSecret_ShouldRequestNewSecretEvenWithinCacheDuration()
{
// Arrange
string expectedFirstSecret = Guid.NewGuid().ToString("N");
string expectedSecondSecret = Guid.NewGuid().ToString("N");
var testProviderStub = new TestSecretProviderStub(expectedFirstSecret);
var cacheInterval = TimeSpan.FromSeconds(10);
const string keyName = "MySecret";
var cachedSecretProvider = new CachedSecretProvider(
testProviderStub,
new CacheConfiguration(cacheInterval));
Secret actualFirst = await cachedSecretProvider.GetSecretAsync(keyName);
testProviderStub.SecretValue = expectedSecondSecret;
// Act
await cachedSecretProvider.InvalidateSecretAsync(keyName);
// Assert
Secret actualSecond = await cachedSecretProvider.GetSecretAsync(keyName);
Assert.True(actualFirst != null, "actualFirst != null");
Assert.True(actualSecond != null, "actualSecond != null");
Assert.Equal(expectedFirstSecret, actualFirst.Value);
Assert.Equal(expectedSecondSecret, actualSecond.Value);
Assert.Equal(2, testProviderStub.CallsMadeSinceCreation);
}
public async Task CachedSecretProvider_GetTwoRawSecretsAsync_SkippedCache_ShouldReturnDifferentValues()
{
// Arrange
string expectedFirstSecret = Guid.NewGuid().ToString("N");
string expectedSecondSecret = Guid.NewGuid().ToString("N");
var spyTestProvider = new TestSecretProviderStub(expectedFirstSecret);
TimeSpan cacheInterval = TimeSpan.FromSeconds(3);
const string keyName = "MyValue";
ICachedSecretProvider cachedSecretProvider = new CachedSecretProvider(
spyTestProvider,
new CacheConfiguration(cacheInterval),
new MemoryCache(new MemoryCacheOptions()));
// Act
string actualFirst = await cachedSecretProvider.GetRawSecretAsync(keyName, ignoreCache : true);
await Task.Delay(TimeSpan.FromSeconds(1));
spyTestProvider.SecretValue = expectedSecondSecret;
string actualSecond = await cachedSecretProvider.GetRawSecretAsync(keyName, ignoreCache : true);
// Assert
Assert.Equal(expectedFirstSecret, actualFirst);
Assert.Equal(expectedSecondSecret, actualSecond);
Assert.Equal(2, spyTestProvider.CallsMadeSinceCreation);
}
public async Task CachedSecretProvider_GetTwoSecretsAsync_OutsideCacheInterval_ShouldReturnDifferentValues()
{
// Arrange
string expectedFirstSecret = Guid.NewGuid().ToString("N");
string expectedSecondSecret = Guid.NewGuid().ToString("N");
var spyTestProvider = new TestSecretProviderStub(expectedFirstSecret);
TimeSpan cacheInterval = TimeSpan.FromMilliseconds(100);
const string keyName = "MyValue";
ICachedSecretProvider cachedSecretProvider = new CachedSecretProvider(
spyTestProvider,
new CacheConfiguration(cacheInterval),
new MemoryCache(new MemoryCacheOptions()));
// Act
Secret actualFirst = await cachedSecretProvider.GetSecretAsync(keyName);
await Task.Delay(TimeSpan.FromSeconds(1));
spyTestProvider.SecretValue = expectedSecondSecret;
Secret actualSecond = await cachedSecretProvider.GetSecretAsync(keyName);
// Assert
Assert.True(actualFirst != null, "actualFirst != null");
Assert.True(actualSecond != null, "actualSecond != null");
Assert.Equal(expectedFirstSecret, actualFirst.Value);
Assert.Equal(expectedSecondSecret, actualSecond.Value);
Assert.Equal(2, spyTestProvider.CallsMadeSinceCreation);
}
public void CachedSecretProvider_CreateWithOnlySecretProvider_ShouldSucceed()
{
// Arrange
string secretKeyValue = Guid.NewGuid().ToString("N");
var testSecretProvider = new TestSecretProviderStub(secretKeyValue);
// Act & Assert
var _ = new CachedSecretProvider(testSecretProvider);
}
public void CachedSecretProvider_CreateWithoutCache_ShouldSucceed()
{
// Arrange
string secretKeyValue = Guid.NewGuid().ToString("N");
var testSecretProvider = new TestSecretProviderStub(secretKeyValue);
var cacheConfiguration = new CacheConfiguration(TimeSpan.MaxValue);
// Act & Assert
var _ = new CachedSecretProvider(testSecretProvider, cacheConfiguration);
}
public void CachedSecretProvider_CreateWithNullCache_ShouldFailWithNullArgument()
{
// Arrange
string secretKeyValue = Guid.NewGuid().ToString("N");
var cacheConfiguration = new CacheConfiguration(TimeSpan.MaxValue);
var testSecretProvider = new TestSecretProviderStub(secretKeyValue);
// Act & Assert
Assert.ThrowsAny <ArgumentNullException>(() => new CachedSecretProvider(testSecretProvider, cacheConfiguration, null));
}
public void CachedSecretProvider_CreateWithCorrectArguments_ShouldSucceed()
{
// Arrange
string secretKeyValue = Guid.NewGuid().ToString("N");
var testSecretProvider = new TestSecretProviderStub(secretKeyValue);
var memCache = new MemoryCache(new MemoryCacheOptions());
var cacheConfiguration = new CacheConfiguration(TimeSpan.MaxValue);
// Act & Assert
ICachedSecretProvider cachedSecretProvider = new CachedSecretProvider(testSecretProvider, cacheConfiguration, memCache);
Assert.NotNull(cachedSecretProvider);
}
public async Task SecretProviderCachingExtensions_TwoCallsWithinCacheInterval_ShouldGetSameValueTwice()
{
// Arrange
string secretKeyValue = Guid.NewGuid().ToString("N");
var testSecretProvider = new TestSecretProviderStub(secretKeyValue);
string keyName = "MyValue";
// Act
ICachedSecretProvider cachedSecretProvider = testSecretProvider.WithCaching(TimeSpan.FromSeconds(3));
var firstValue = await cachedSecretProvider.GetRawSecretAsync(keyName);
testSecretProvider.SecretValue = Guid.NewGuid().ToString("N"); // Change actual value on the internal secret provider !
var secondValue = await cachedSecretProvider.GetRawSecretAsync(keyName);
// Assert
Assert.Equal(firstValue, secondValue);
Assert.Equal(1, testSecretProvider.CallsMadeSinceCreation);
}
public async Task ConfigureSecretStore_WithFoundLazyCachedSecretProvider_UsesLazyRegisteredSecretProvider()
{
// Arrange
string expected = $"secret-{Guid.NewGuid()}";
var stubProvider = new TestSecretProviderStub(expected);
var builder = new HostBuilder();
// Act
builder.ConfigureSecretStore((config, stores) => stores.AddProvider(serviceProvider => stubProvider));
// Assert
IHost host = builder.Build();
var provider = host.Services.GetRequiredService <ICachedSecretProvider>();
string actual = await provider.GetRawSecretAsync("ignored-key");
Assert.Equal(expected, actual);
Assert.Equal(1, stubProvider.CallsMadeSinceCreation);
}
public async Task SecretProviderCachingExtensions_TwoCallsOutsideCacheInterval_ShouldGetDifferentValue()
{
// Arrange
string secretKeyValue = Guid.NewGuid().ToString("N");
var testSecretProvider = new TestSecretProviderStub(secretKeyValue);
string keyName = "MyValue";
// Act
ICachedSecretProvider cachedSecretProvider = testSecretProvider.WithCaching(TimeSpan.FromMilliseconds(100));
var firstValue = await cachedSecretProvider.GetRawSecretAsync(keyName);
await Task.Delay(TimeSpan.FromMilliseconds(150));
string newSecretValue = Guid.NewGuid().ToString("N");
testSecretProvider.SecretValue = newSecretValue; // Change actual value on the internal secret provider !
var secondValue = await cachedSecretProvider.GetRawSecretAsync(keyName);
// Assert
Assert.Equal(secretKeyValue, firstValue);
Assert.Equal(newSecretValue, secondValue);
Assert.Equal(2, testSecretProvider.CallsMadeSinceCreation);
}
