public void GetAllAdalEntriesForMsal_FilterBy_Upn()
        {
            // Arrange
            LegacyTokenCacheHelper.PopulateLegacyCache(_logger, _legacyCachePersistence);

            // Act - query Adal Entries For Msal with valid Upn as a filter
            var rt =
                CacheFallbackOperations.GetRefreshToken(
                    _logger,
                    _legacyCachePersistence,
                    new[] {
                TestConstants.ProductionPrefNetworkEnvironment,
                TestConstants.SovereignNetworkEnvironment
            },
                    TestConstants.ClientId,
                    new Account(null, "User1", null));

            Assert.AreEqual("uid1.tenantId1", rt.HomeAccountId);

            // Act - query Adal Entries For Msal with invalid Upn as a filter
            rt =
                CacheFallbackOperations.GetRefreshToken(
                    _logger,
                    _legacyCachePersistence,
                    new[] {
                TestConstants.ProductionPrefNetworkEnvironment,
                TestConstants.SovereignNetworkEnvironment
            },
                    TestConstants.ClientId,
                    new Account(null, "UserX", null));

            Assert.IsNull(rt, "Expected to find no items");
        }
        public void GetAllAdalUsersForMsal_ScopedBy_ClientIdAndEnv()
        {
            // Arrange
            LegacyTokenCacheHelper.PopulateLegacyCache(_logger, _legacyCachePersistence);

            // Act - query users by env and clientId
            var adalUsers =
                CacheFallbackOperations.GetAllAdalUsersForMsal(
                    _logger,
                    _legacyCachePersistence,
                    TestConstants.ClientId);

            AssertByUsername(
                adalUsers,
                new[] {
                TestConstants.ProductionPrefNetworkEnvironment,
                TestConstants.SovereignNetworkEnvironment
            },
                new[]
            {
                "user1",
                "user2",
                "sovereign_user5"
            },
                new[]
            {
                "no_client_info_user3",
                "no_client_info_user4"
            });

            AssertByUsername(
                adalUsers,
                new[] {
                TestConstants.SovereignNetworkEnvironment
            },
                new[]
            {
                "sovereign_user5"
            },
                Enumerable.Empty <string>());

            // Act - query users for different clientId and env
            adalUsers = CacheFallbackOperations.GetAllAdalUsersForMsal(
                _logger,
                _legacyCachePersistence,
                "other_client_id");

            // Assert
            AssertByUsername(
                adalUsers,
                null,
                new[]
            {
                "user6"
            },
                Enumerable.Empty <string>());
        }
        public void RemoveAdalUser_RemovesUserWithSameId()
        {
            // Arrange
            LegacyTokenCacheHelper.PopulateLegacyCache(_logger, _legacyCachePersistence);

            LegacyTokenCacheHelper.PopulateLegacyWithRtAndId( // different clientId -> should not be deleted
                _logger,
                _legacyCachePersistence,
                "other_client_id",
                TestConstants.ProductionPrefNetworkEnvironment,
                "uid1",
                "tenantId1",
                "user1_other_client_id");

            LegacyTokenCacheHelper.PopulateLegacyWithRtAndId( // different env -> should be deleted
                _logger,
                _legacyCachePersistence,
                TestConstants.ClientId,
                "other_env",
                "uid1",
                "tenantId1",
                "user1_other_env");

            // Act - delete with id and displayname
            CacheFallbackOperations.RemoveAdalUser(
                _logger,
                _legacyCachePersistence,
                TestConstants.ClientId,
                "username_does_not_matter",
                "uid1.tenantId1");

            // Assert
            var adalUsers =
                CacheFallbackOperations.GetAllAdalUsersForMsal(
                    _logger,
                    _legacyCachePersistence,
                    TestConstants.ClientId);

            AssertByUsername(
                adalUsers,
                new[] { TestConstants.ProductionPrefNetworkEnvironment },
                new[]
            {
                "user2",
            },
                new[]
            {
                "no_client_info_user3",
                "no_client_info_user4"
            });
        }
예제 #4
0
        public void GlobalSetup()
        {
            var serviceBundle = TestCommon.CreateServiceBundleWithCustomHttpManager(null, isLegacyCacheEnabled: EnableLegacyCache);

            _cache    = new TokenCache(serviceBundle, false);
            _response = TestConstants.CreateMsalTokenResponse(TestConstants.Utid);

            _requestParams         = TestCommon.CreateAuthenticationRequestParameters(serviceBundle);
            _requestParams.Account = new Account(TestConstants.s_userIdentifier, $"1{TestConstants.DisplayableId}", TestConstants.ProductionPrefNetworkEnvironment);

            AddHostToInstanceCache(serviceBundle, TestConstants.ProductionPrefCacheEnvironment);

            LegacyTokenCacheHelper.PopulateLegacyCache(serviceBundle.ApplicationLogger, _cache.LegacyPersistence, TokenCacheSize);
            TokenCacheHelper.AddRefreshTokensToCache(_cache.Accessor, TokenCacheSize);
        }
        public void GetAllAdalEntriesForMsal_NoFilter()
        {
            // Arrange
            LegacyTokenCacheHelper.PopulateLegacyCache(_logger, _legacyCachePersistence);

            // Act - query Adal Entries For Msal with valid Upn and UniqueId as a filter
            var rt =
                CacheFallbackOperations.GetRefreshToken(
                    _logger,
                    _legacyCachePersistence,
                    new[] {
                TestConstants.ProductionPrefNetworkEnvironment,
                TestConstants.SovereignNetworkEnvironment
            },
                    TestConstants.ClientId,
                    new Account(null, null, null)); // too litle info here, do not return RT

            Assert.IsNull(rt, "Expected to find no items");
        }
        public void RemoveAdalUser_RemovesUserNoClientInfo_And_NoDisplayName()
        {
            // Arrange
            LegacyTokenCacheHelper.PopulateLegacyCache(_logger, _legacyCachePersistence);
            IDictionary <AdalTokenCacheKey, AdalResultWrapper> adalCacheBeforeDelete =
                AdalCacheOperations.Deserialize(_logger, _legacyCachePersistence.LoadCache());

            Assert.AreEqual(6, adalCacheBeforeDelete.Count);

            // Act - nothing happens and a message is logged
            CacheFallbackOperations.RemoveAdalUser(
                _logger,
                _legacyCachePersistence,
                TestConstants.ClientId,
                "",
                "");

            // Assert
            AssertCacheEntryCount(6);

            _logger.Received().Error(Arg.Is <string>(MsalErrorMessage.InternalErrorCacheEmptyUsername));
        }
        public void RemoveAdalUser_RemovesUserNoClientInfo()
        {
            // Arrange
            LegacyTokenCacheHelper.PopulateLegacyCache(_logger, _legacyCachePersistence);

            LegacyTokenCacheHelper.PopulateLegacyWithRtAndId(
                _logger,
                _legacyCachePersistence,
                "other_client_id",
                TestConstants.ProductionPrefNetworkEnvironment,
                null,
                null,
                "no_client_info_user3"); // no client info, different client id -> won't be deleted

            LegacyTokenCacheHelper.PopulateLegacyWithRtAndId(
                _logger,
                _legacyCachePersistence,
                TestConstants.ClientId,
                "other_env",
                null,
                null,
                "no_client_info_user3"); // no client info, different env -> won't be deleted

            AssertCacheEntryCount(8);

            var adalUsers =
                CacheFallbackOperations.GetAllAdalUsersForMsal(
                    _logger,
                    _legacyCachePersistence,
                    TestConstants.ClientId);

            AssertByUsername(
                adalUsers,
                new[] { TestConstants.ProductionPrefNetworkEnvironment },
                new[]
            {
                "user2",
                "user1",
            },
                new[]
            {
                "no_client_info_user3",
                "no_client_info_user4"
            });

            // Act - delete with no client info -> displayable id is used
            CacheFallbackOperations.RemoveAdalUser(
                _logger,
                _legacyCachePersistence,
                TestConstants.ClientId,
                "no_client_info_user3",
                "");

            AssertCacheEntryCount(6);

            // Assert
            adalUsers = CacheFallbackOperations.GetAllAdalUsersForMsal(
                _logger,
                _legacyCachePersistence,
                TestConstants.ClientId);

            AssertByUsername(
                adalUsers,
                new[] { TestConstants.ProductionPrefNetworkEnvironment },
                new[]
            {
                "user2",
                "user1",
            },
                new[]
            {
                "no_client_info_user4"
            });
        }