AccidentalFish.ApplicationSupport.Azure.Configuration.AsyncKeyVaultConfiguration.GetAsync C# (CSharp) Method

        public async Task<string> GetAsync(string key)
        {
            string value = null;
            CachedApplicationSetting cachedSetting;
            if (_cachedSettings.TryGetValue(key, out cachedSetting))
            {
                if (cachedSetting.ExpiresAt > DateTimeOffset.UtcNow)
                {
                    value = cachedSetting.Value;
                }
            }

            if (value == null)
            {
                if (_localConfiguration != null)
                {
                    value = await _localConfiguration.GetAsync(key);
                }
                if (string.IsNullOrWhiteSpace(value))
                {
                    try
                    {
                        string keyVaultEncodedKey = _keyEncoder.Encode(key);
                        value = await _vault.GetSecretAsync(keyVaultEncodedKey);
                    }
                    catch (AggregateException ex)
                    {
                        KeyVaultClientException kex = ex.InnerExceptions.FirstOrDefault() as KeyVaultClientException;
                        if (kex != null && kex.Status == HttpStatusCode.NotFound)
                        {
                            value = null;
                        }
                        else
                        {
                            throw;
                        }
                    }
                }

                if (_cachePolicy != null)
                {
                    if (value != null || _cachePolicy.CacheNotFoundAsNull)
                    {
                        CachedApplicationSetting newSetting = new CachedApplicationSetting
                        {
                            ExpiresAt = DateTimeOffset.UtcNow.Add(_cachePolicy.ExpiresAfter),
                            Key = key,
                            Value = value
                        };
                        _cachedSettings.AddOrUpdate(key, newSetting, (k, e) => newSetting);
                    }
                }
            }

            return value;
        }        
    }

        public async Task GetsFromCache()
        {
            Mock<IKeyVault> keyVault = new Mock<IKeyVault>();
            Mock<IKeyVaultConfigurationKeyEncoder> keyVaultEncoder = new Mock<IKeyVaultConfigurationKeyEncoder>();
            Mock<IAsyncConfiguration> asyncConfiguration = new Mock<IAsyncConfiguration>();

            keyVaultEncoder.Setup(x => x.Encode("mykey")).Returns("mykey");
            asyncConfiguration.Setup(x => x.GetAsync("mykey")).ReturnsAsync("incache");
            
            AsyncKeyVaultConfiguration asyncKeyVaultConfiguration = new AsyncKeyVaultConfiguration(keyVault.Object, keyVaultEncoder.Object, KeyVaultConfigurationCachePolicy.Default, asyncConfiguration.Object);

            await asyncKeyVaultConfiguration.GetAsync("mykey");
            string result = await asyncKeyVaultConfiguration.GetAsync("mykey");
            Assert.AreEqual("incache", result);
            asyncConfiguration.Verify(x => x.GetAsync("mykey"), Times.AtMostOnce);
        }