public static void UpdateTokenExpiryOnTokenCache(TokenCache cache, DateTimeOffset newExpiry)
{
var cacheDictionary = cache.tokenCacheDictionary;
var key = cacheDictionary.Keys.First();
cache.tokenCacheDictionary[key].ExpiresOn = newExpiry;
var value = cacheDictionary.Values.First();
cache.Clear();
cacheDictionary.Add(key, value);
}
public void ClearCache()
{
string cache_filename = GetTokenCachePath();
if (System.IO.File.Exists(cache_filename))
{
var bytes = System.IO.File.ReadAllBytes(cache_filename);
var token_cache = new MSAD.TokenCache(bytes);
token_cache.Clear();
System.IO.File.WriteAllBytes(cache_filename, token_cache.Serialize());
}
}
public void ClearCache()
{
string cache_filename = GetTokenCachePath();
if (System.IO.File.Exists(cache_filename))
{
var bytes = System.IO.File.ReadAllBytes(cache_filename);
var token_cache = new Microsoft.IdentityModel.Clients.ActiveDirectory.TokenCache(bytes);
token_cache.Clear();
System.IO.File.WriteAllBytes(cache_filename, token_cache.Serialize());
}
}
internal static void TokenCacheValueSplitTest()
{
var tokenCache = new TokenCache();
TokenCacheKey key = new TokenCacheKey("https://localhost/MockSts", "resourc1", "client1", TokenSubjectType.User, null, "user1");
tokenCache.Clear();
AddToDictionary(tokenCache, key, null);
Verify.AreEqual(tokenCache.tokenCacheDictionary[key], null);
for (int len = 0; len < 3000; len++)
{
var value = CreateCacheValue(null, "user1");
tokenCache.Clear();
AddToDictionary(tokenCache, key, value);
Verify.AreEqual(tokenCache.tokenCacheDictionary[key], value);
}
}
internal static void TokenCacheCapacityTest()
{
var tokenCache = new TokenCache();
tokenCache.Clear();
const int MaxItemCount = 100;
const int MaxFieldSize = 256;
TokenCacheKey[] keys = new TokenCacheKey[MaxItemCount];
AuthenticationResult[] values = new AuthenticationResult[MaxItemCount];
for (int i = 0; i < MaxItemCount; i++)
{
keys[i] = GenerateRandomTokenCacheKey(MaxFieldSize);
values[i] = CreateCacheValue(null, null);
AddToDictionary(tokenCache, keys[i], values[i]);
}
Verify.AreEqual(MaxItemCount, tokenCache.Count);
for (int i = 0; i < MaxItemCount; i++)
{
AuthenticationResult cacheValue;
int index = MaxItemCount - i - 1;
Verify.IsTrue(tokenCache.tokenCacheDictionary.TryGetValue(keys[index], out cacheValue));
Verify.AreEqual(values[index], cacheValue);
RemoveFromDictionary(tokenCache, keys[index]);
Verify.AreEqual(index, tokenCache.Count);
}
tokenCache.Clear();
}
internal static void TokenCacheOperationsTest()
{
var tokenCache = new TokenCache();
var cacheDictionary = tokenCache.tokenCacheDictionary;
tokenCache.Clear();
TokenCacheKey key = new TokenCacheKey("https://localhost/MockSts", "resource1", "client1", TokenSubjectType.User, null, "user1");
TokenCacheKey key2 = new TokenCacheKey("https://localhost/MockSts", "resource1", "client1", TokenSubjectType.User, null, "user2");
TokenCacheKey key3 = new TokenCacheKey("https://localhost/MockSts", "resource1", "client1", TokenSubjectType.UserPlusClient, null, "user1");
Verify.AreNotEqual(key, key3);
var value = CreateCacheValue(null, "user1");
AuthenticationResult value2;
do
{
value2 = CreateCacheValue(null, "user2");
}
while (value2 == value);
Verify.AreEqual(0, cacheDictionary.Count);
AddToDictionary(tokenCache, key, value);
Verify.AreEqual(1, cacheDictionary.Count);
var valueInCache = cacheDictionary[key];
VerifyAuthenticationResultsAreEqual(valueInCache, value);
VerifyAuthenticationResultsAreNotEqual(valueInCache, value2);
cacheDictionary[key] = value2;
Verify.AreEqual(1, cacheDictionary.Count);
valueInCache = cacheDictionary[key];
VerifyAuthenticationResultsAreEqual(valueInCache, value2);
VerifyAuthenticationResultsAreNotEqual(valueInCache, value);
try
{
AddToDictionary(tokenCache, key, value);
Verify.Fail("Exception expected due to duplicate key");
}
catch (ArgumentException)
{
// Expected
}
Verify.IsTrue(RemoveFromDictionary(tokenCache, key));
Verify.IsFalse(RemoveFromDictionary(tokenCache, key));
Verify.AreEqual(0, cacheDictionary.Count);
AddToDictionary(tokenCache, key, value);
AddToDictionary(tokenCache, key2, value2);
Verify.AreEqual(2, cacheDictionary.Count);
Verify.AreEqual(cacheDictionary[key], value);
Verify.AreEqual(cacheDictionary[key2], value2);
try
{
AddToDictionary(tokenCache, null, value);
Verify.Fail("Exception expected due to duplicate key");
}
catch (ArgumentNullException)
{
// Expected
}
try
{
cacheDictionary[null] = value;
Verify.Fail("Exception expected due to duplicate key");
}
catch (ArgumentNullException)
{
// Expected
}
Verify.IsFalse(cacheDictionary.IsReadOnly);
var keys = cacheDictionary.Keys.ToList();
var values = cacheDictionary.Values.ToList();
Verify.AreEqual(2, keys.Count);
Verify.AreEqual(2, values.Count);
if (keys[0].Equals(key))
{
Verify.AreEqual(keys[1], key2);
Verify.AreEqual(values[0], value);
Verify.AreEqual(values[1], value2);
}
else
{
Verify.AreEqual(keys[0], key2);
Verify.AreEqual(keys[1], key);
Verify.AreEqual(values[0], value2);
Verify.AreEqual(values[1], value);
}
Verify.IsTrue(cacheDictionary.ContainsKey(key));
Verify.IsTrue(cacheDictionary.ContainsKey(key2));
Verify.IsFalse(cacheDictionary.ContainsKey(key3));
Verify.IsTrue(cacheDictionary.Contains(new KeyValuePair<TokenCacheKey, AuthenticationResult>(key, value)));
Verify.IsTrue(cacheDictionary.Contains(new KeyValuePair<TokenCacheKey, AuthenticationResult>(key2, value2)));
Verify.IsFalse(cacheDictionary.Contains(new KeyValuePair<TokenCacheKey, AuthenticationResult>(key, value2)));
Verify.IsFalse(cacheDictionary.Contains(new KeyValuePair<TokenCacheKey, AuthenticationResult>(key2, value)));
try
{
AddToDictionary(tokenCache, key, value);
Verify.Fail("Exception expected due to duplicate key");
}
catch (ArgumentException)
{
// Expected
}
AddToDictionary(tokenCache, key3, value);
Verify.AreEqual(3, cacheDictionary.Keys.Count);
Verify.IsTrue(cacheDictionary.ContainsKey(key3));
var cacheItemsCopy = new KeyValuePair<TokenCacheKey, AuthenticationResult>[cacheDictionary.Count + 1];
cacheDictionary.CopyTo(cacheItemsCopy, 1);
for (int i = 0; i < cacheDictionary.Count; i++)
{
Verify.AreEqual(cacheItemsCopy[i + 1].Value, cacheDictionary[cacheItemsCopy[i + 1].Key]);
}
try
{
cacheDictionary.CopyTo(cacheItemsCopy, 2);
Verify.Fail("Exception expected");
}
catch (ArgumentException)
{
// Expected
}
try
{
cacheDictionary.CopyTo(cacheItemsCopy, -1);
Verify.Fail("Exception expected");
}
catch (ArgumentOutOfRangeException)
{
// Expected
}
RemoveFromDictionary(tokenCache, key2);
Verify.AreEqual(2, cacheDictionary.Keys.Count);
foreach (var kvp in cacheDictionary)
{
Verify.IsTrue(kvp.Key.Equals(key) || kvp.Key.Equals(key3));
Verify.IsTrue(kvp.Value.Equals(value));
}
AuthenticationResult cacheValue;
Verify.IsTrue(cacheDictionary.TryGetValue(key, out cacheValue));
Verify.AreEqual(cacheValue, value);
Verify.IsTrue(cacheDictionary.TryGetValue(key3, out cacheValue));
Verify.AreEqual(cacheValue, value);
Verify.IsFalse(cacheDictionary.TryGetValue(key2, out cacheValue));
cacheDictionary.Clear();
Verify.AreEqual(0, cacheDictionary.Keys.Count);
}