public void GetAccount_Test()
        {
            var accessor = new InMemoryPartitionedUserTokenCacheAccessor(new NullLogger(), null);
            var acc1     = TokenCacheHelper.CreateAccountItem("tenant1", "homeAccountId");
            var acc2     = TokenCacheHelper.CreateAccountItem("tenant1", "homeAccountId2");
            var acc3     = TokenCacheHelper.CreateAccountItem("tenant2", "homeAccountId");

            // Assert: Null non-existing item
            Assert.IsNull(accessor.GetAccount(acc1.GetKey()));

            accessor.SaveAccount(acc1);
            accessor.SaveAccount(acc2);
            accessor.SaveAccount(acc3);

            // Assert: Get token by key
            Assert.AreEqual(acc2.GetKey(), accessor.GetAccount(acc2.GetKey()).GetKey());
            Assert.AreEqual(acc3.GetKey(), accessor.GetAccount(acc3.GetKey()).GetKey());
        }
Beispiel #2
0
        private ITokenCacheAccessor CreateTokenCacheAccessorWithKeyPrefix(
            string keyPrefix,
            int numAccessTokens,
            int numRefreshTokens,
            int numIdTokens,
            int numAccounts)
        {
            var accessor = new InMemoryPartitionedUserTokenCacheAccessor(Substitute.For <ICoreLogger>(), null);

            for (int i = 1; i <= numAccessTokens; i++)
            {
                var item = CreateAccessTokenItem(
                    cachedAt: DateTimeHelpers.UnixTimestampToDateTime(34567),
                    expiresOn: DateTimeHelpers.UnixTimestampToDateTime(12345),
                    extendedExpiresOn: DateTimeHelpers.UnixTimestampToDateTime(23456));

                item.Environment = item.Environment + $"_{keyPrefix}{i}"; // ensure we get unique cache keys
                accessor.SaveAccessToken(item);
            }

            for (int i = 1; i <= numRefreshTokens; i++)
            {
                var item = CreateRefreshTokenItem();
                item.Environment = item.Environment + $"_{keyPrefix}{i}"; // ensure we get unique cache keys
                accessor.SaveRefreshToken(item);
            }

            // Create an FRT
            var frt = CreateRefreshTokenItem(true);

            frt.FamilyId = "1";
            accessor.SaveRefreshToken(frt);

            for (int i = 1; i <= numIdTokens; i++)
            {
                var item = CreateIdTokenItem();
                item.Environment = item.Environment + $"_{keyPrefix}{i}"; // ensure we get unique cache keys
                accessor.SaveIdToken(item);
            }

            for (int i = 1; i <= numAccounts; i++)
            {
                var item = CreateAccountItem();
                item.Environment = item.Environment + $"_{keyPrefix}{i}"; // ensure we get unique cache keys
                accessor.SaveAccount(item);
            }

            accessor.SaveAppMetadata(new MsalAppMetadataCacheItem(TestConstants.ClientId, "env_1", "1"));
            accessor.SaveAppMetadata(new MsalAppMetadataCacheItem(TestConstants.ClientId, "env_2", ""));
            accessor.SaveAppMetadata(new MsalAppMetadataCacheItem(TestConstants.ClientId2, "env_1", "another_family"));

            return(accessor);
        }
        public void DeleteAccount_Test()
        {
            var accessor = new InMemoryPartitionedUserTokenCacheAccessor(new NullLogger(), null);
            var acc1     = TokenCacheHelper.CreateAccountItem("tenant1", "homeAccountId");
            var acc2     = TokenCacheHelper.CreateAccountItem("tenant1", "homeAccountId2");
            var acc3     = TokenCacheHelper.CreateAccountItem("tenant2", "homeAccountId");

            // Assert: Delete on empty collection doesn't throw
            accessor.DeleteAccount(acc1);

            accessor.SaveAccount(acc1);
            accessor.SaveAccount(acc2);
            accessor.SaveAccount(acc3);

            Assert.AreEqual(3, accessor.GetAllAccounts().Count);

            // Assert: Delete on existing item
            accessor.DeleteAccount(acc1);

            Assert.AreEqual(2, accessor.GetAllAccounts().Count);
        }
        public void GetAllAccounts_Test()
        {
            var    accessor      = new InMemoryPartitionedUserTokenCacheAccessor(new NullLogger(), null);
            var    acc1          = TokenCacheHelper.CreateAccountItem("tenant1", "homeAccountId");
            var    acc2          = TokenCacheHelper.CreateAccountItem("tenant1", "homeAccountId2");
            var    acc3          = TokenCacheHelper.CreateAccountItem("tenant2", "homeAccountId");
            string partitionKey1 = CacheKeyFactory.GetKeyFromCachedItem(acc1);
            string partitionKey2 = CacheKeyFactory.GetKeyFromCachedItem(acc2);

            // Assert: Returns empty collection
            Assert.AreEqual(0, accessor.GetAllAccounts().Count);
            Assert.AreEqual(0, accessor.GetAllAccounts(partitionKey1).Count);

            accessor.SaveAccount(acc1);
            accessor.SaveAccount(acc2);
            accessor.SaveAccount(acc3);

            // Assert: Get all tokens and get all tokens by partition key
            Assert.AreEqual(3, accessor.GetAllAccounts().Count);
            Assert.AreEqual(2, accessor.GetAllAccounts(partitionKey1).Count);
            Assert.AreEqual(1, accessor.GetAllAccounts(partitionKey2).Count);
        }
        public void SaveAccount_Test()
        {
            var accessor = new InMemoryPartitionedUserTokenCacheAccessor(new NullLogger(), null);

            var acc1 = TokenCacheHelper.CreateAccountItem("tenant1", "homeAccountId");

            // Assert: Saves with new item
            accessor.SaveAccount(acc1);

            Assert.AreEqual(1, accessor.GetAllAccounts().Count);
            Assert.AreEqual(1, accessor.AccountCacheDictionary.Count);
            string partitionKey1 = CacheKeyFactory.GetKeyFromCachedItem(acc1);

            Assert.IsNotNull(accessor.AccountCacheDictionary[partitionKey1][acc1.GetKey().ToString()]);

            var acc2 = TokenCacheHelper.CreateAccountItem("tenant2", "homeAccountId");

            // Assert: Save under the existing partition
            accessor.SaveAccount(acc2);

            Assert.AreEqual(2, accessor.GetAllAccounts().Count);
            Assert.AreEqual(1, accessor.AccountCacheDictionary.Count);
            Assert.IsNotNull(accessor.AccountCacheDictionary[partitionKey1][acc2.GetKey().ToString()]);

            var acc3 = TokenCacheHelper.CreateAccountItem("tenant1", "homeAccountId2");

            // Assert: Save under a new partition
            accessor.SaveAccount(acc3);
            // Assert: Save overwrites the existing token
            accessor.SaveAccount(acc3);

            Assert.AreEqual(3, accessor.GetAllAccounts().Count);
            Assert.AreEqual(2, accessor.AccountCacheDictionary.Count);
            string partitionKey2 = CacheKeyFactory.GetKeyFromCachedItem(acc3);

            Assert.IsNotNull(accessor.AccountCacheDictionary[partitionKey2][acc3.GetKey().ToString()]);
        }
        public void ClearCache_UserCache_Test()
        {
            var accessor = new InMemoryPartitionedUserTokenCacheAccessor(new NullLogger(), null);

            accessor.SaveAccessToken(TokenCacheHelper.CreateAccessTokenItem());
            accessor.SaveRefreshToken(TokenCacheHelper.CreateRefreshTokenItem());
            accessor.SaveIdToken(TokenCacheHelper.CreateIdTokenCacheItem());
            accessor.SaveAccount(TokenCacheHelper.CreateAccountItem());

            Assert.AreEqual(1, accessor.AccessTokenCacheDictionary.Count);
            Assert.AreEqual(1, accessor.RefreshTokenCacheDictionary.Count);
            Assert.AreEqual(1, accessor.IdTokenCacheDictionary.Count);
            Assert.AreEqual(1, accessor.AccountCacheDictionary.Count);

            accessor.Clear();

            Assert.AreEqual(0, accessor.AccessTokenCacheDictionary.Count);
            Assert.AreEqual(0, accessor.RefreshTokenCacheDictionary.Count);
            Assert.AreEqual(0, accessor.IdTokenCacheDictionary.Count);
            Assert.AreEqual(0, accessor.AccountCacheDictionary.Count);
        }