public async Task GetAccountAsync_CachesAccounts()
        {
            var services    = CreateServices();
            var accountMock = new Mock <IStorageAccount>();
            var storageMock = new Mock <IStorageAccount>();

            var csProvider = CreateConnectionStringProvider("account", "cs");
            var parser     = CreateParser(services, "account", "cs", accountMock.Object);

            // strick mock tests that validate does not occur twice
            Mock <IStorageCredentialsValidator> validatorMock = new Mock <IStorageCredentialsValidator>(MockBehavior.Strict);

            validatorMock.Setup(v => v.ValidateCredentialsAsync(accountMock.Object, It.IsAny <CancellationToken>()))
            .Returns(Task.CompletedTask);
            validatorMock.Setup(v => v.ValidateCredentialsAsync(storageMock.Object, It.IsAny <CancellationToken>()))
            .Returns(Task.CompletedTask);

            DefaultStorageAccountProvider provider = CreateProductUnderTest(services, csProvider, parser, validatorMock.Object);
            var account = await provider.TryGetAccountAsync("account", CancellationToken.None);

            var account2 = await provider.TryGetAccountAsync("account", CancellationToken.None);

            Assert.Equal(account, account2);
            validatorMock.Verify(v => v.ValidateCredentialsAsync(accountMock.Object, It.IsAny <CancellationToken>()), Times.Once());
        }
        public async Task GetAccountAsync_WhenNoStorage_Succeeds()
        {
            DefaultStorageAccountProvider provider = CreateProductUnderTest();

            provider.DashboardConnectionString = null;
            provider.StorageConnectionString   = null;

            var dashboardAccount = await provider.TryGetAccountAsync(ConnectionStringNames.Dashboard, CancellationToken.None);

            Assert.Null(dashboardAccount);

            var storageAccount = await provider.TryGetAccountAsync(ConnectionStringNames.Storage, CancellationToken.None);

            Assert.Null(storageAccount);
        }
        public async Task GetAccountAsync_WhenStorageOverriddenWithNull_Succeeds()
        {
            DefaultStorageAccountProvider provider = CreateProductUnderTest();

            provider.StorageConnectionString = null;

            var account = await provider.TryGetAccountAsync(ConnectionStringNames.Storage, CancellationToken.None);

            Assert.Null(account);
        }
        public void GetAccountAsync_WhenDashboardOverriddenWithNull_ReturnsNull()
        {
            DefaultStorageAccountProvider provider = CreateProductUnderTest();

            provider.DashboardConnectionString = null;

            IStorageAccount actualAccount = provider.TryGetAccountAsync(
                ConnectionStringNames.Dashboard, CancellationToken.None).GetAwaiter().GetResult();

            Assert.Null(actualAccount);
        }
        public void GetAccountAsync_WhenDashboardOverridden_ReturnsParsedAccount()
        {
            IConnectionStringProvider connectionStringProvider = CreateDummyConnectionStringProvider();
            string                        connectionString     = "valid-ignore";
            IStorageAccount               parsedAccount        = Mock.Of <IStorageAccount>();
            IServiceProvider              services             = CreateServices();
            IStorageAccountParser         parser    = CreateParser(services, ConnectionStringNames.Dashboard, connectionString, parsedAccount);
            IStorageCredentialsValidator  validator = CreateValidator(parsedAccount);
            DefaultStorageAccountProvider provider  = CreateProductUnderTest(services, connectionStringProvider, parser, validator);

            provider.DashboardConnectionString = connectionString;
            IStorageAccount actualAccount = provider.TryGetAccountAsync(
                ConnectionStringNames.Dashboard, CancellationToken.None).GetAwaiter().GetResult();

            Assert.Same(parsedAccount, actualAccount);
        }