public void RemoveTest(bool useCustomCreateCacheCallback)
{
long result;
var cache = new PerTenantNonSharingCache <long, long>("Test Cache", useCustomCreateCacheCallback ? new Func <ICache <long, long> >(CreatePerTenantCache) : null);
// Populate the cache
PopulateCache(cache);
// Remove an entry from tenant 1
SetTenant(Tenant1Id);
cache.Remove(_tenant1Values[0].Item1);
// Remove two entries from tenant 2
SetTenant(Tenant2Id);
cache.Remove(_tenant2Values[0].Item1);
cache.Remove(_tenant2Values[1].Item1);
// Verify entries have been removed
SetTenant(Tenant1Id);
Assert.AreEqual(_tenant1Values.Count - 1, cache.Count);
Assert.IsFalse(cache.TryGetValue(_tenant1Values[0].Item1, out result));
// Verify entries have been removed
SetTenant(Tenant2Id);
Assert.AreEqual(_tenant2Values.Count - 2, cache.Count);
Assert.IsFalse(cache.TryGetValue(_tenant2Values[0].Item1, out result));
Assert.IsFalse(cache.TryGetValue(_tenant2Values[1].Item1, out result));
}
public void IndexerTest(bool useCustomCreateCacheCallback)
{
var cache = new PerTenantNonSharingCache <long, long>("Test Cache", useCustomCreateCacheCallback ? new Func <ICache <long, long> >(CreatePerTenantCache) : null);
// Populate the cache
PopulateCacheViaIndexer(cache);
// Verify that the entries are valid for tenant 1
SetTenant(Tenant1Id);
Assert.AreEqual(_tenant1Values.Count, cache.Count);
foreach (var v in _tenant1Values)
{
Assert.AreEqual(v.Item2, cache[v.Item1]);
}
foreach (var v in _tenant2Values)
{
Assert.AreEqual(0, cache[v.Item1]);
}
// Verify that the entries are valid for tenant 2
SetTenant(Tenant2Id);
Assert.AreEqual(_tenant2Values.Count, cache.Count);
foreach (var v in _tenant2Values)
{
Assert.AreEqual(v.Item2, cache[v.Item1]);
}
foreach (var v in _tenant1Values)
{
Assert.AreEqual(0, cache[v.Item1]);
}
}
public void ClearTest(bool useCustomCreateCacheCallback)
{
var innerCache = CreatePerTenantCache();
var cache = new PerTenantNonSharingCache <long, long>("Test Cache", useCustomCreateCacheCallback ? new Func <ICache <long, long> >(() => innerCache) : null);
// Populate the cache
PopulateCache(cache);
// Clear the cache for tenant 1
SetTenant(Tenant1Id);
cache.Clear();
// Verify that the cache is empty for tenant 1
Assert.AreEqual(0, cache.Count);
// Assert that the inner cache was explicitly cleared (because Redis needs this)
if (useCustomCreateCacheCallback)
{
Assert.AreEqual(0, innerCache.Count);
}
// Verify that the cache is not empty for tenant 2
SetTenant(Tenant2Id);
Assert.AreEqual(_tenant2Values.Count, cache.Count);
}
public void AddTest(bool useCustomCreateCacheCallback)
{
long result;
var cache = new PerTenantNonSharingCache <long, long>("Test Cache", useCustomCreateCacheCallback ? new Func <ICache <long, long> >(CreatePerTenantCache) : null);
// Populate the cache
PopulateCache(cache);
// Verify that the entries are valid for tenant 1
SetTenant(Tenant1Id);
Assert.AreEqual(_tenant1Values.Count, cache.Count);
foreach (var v in _tenant1Values)
{
Assert.IsTrue(cache.TryGetValue(v.Item1, out result));
Assert.AreEqual(v.Item2, result);
}
// Verify that the entries are valid for tenant 2
SetTenant(Tenant2Id);
Assert.AreEqual(_tenant2Values.Count, cache.Count);
foreach (var v in _tenant2Values)
{
Assert.IsTrue(cache.TryGetValue(v.Item1, out result));
Assert.AreEqual(v.Item2, result);
}
}
/// <summary>
/// Populates the cache.
/// </summary>
/// <param name="cache">The cache.</param>
private void PopulateCacheViaIndexer(PerTenantNonSharingCache <long, long> cache)
{
// Populate the cache for tenant 1
SetTenant(Tenant1Id);
foreach (var v in _tenant1Values)
{
cache[v.Item1] = v.Item2;
}
// Populate the cache for tenant 2
SetTenant(Tenant2Id);
foreach (var v in _tenant2Values)
{
cache[v.Item1] = v.Item2;
}
}
/// <summary>
/// Populates the cache.
/// </summary>
/// <param name="cache">The cache.</param>
private void PopulateCache(PerTenantNonSharingCache <long, long> cache)
{
// Populate the cache for tenant 1
SetTenant(Tenant1Id);
foreach (var v in _tenant1Values)
{
cache.Add(v.Item1, v.Item2);
}
// Populate the cache for tenant 2
SetTenant(Tenant2Id);
foreach (var v in _tenant2Values)
{
cache.Add(v.Item1, v.Item2);
}
}
public void ClearAllTest(bool useCustomCreateCacheCallback)
{
var cache = new PerTenantNonSharingCache <long, long>("Test Cache", useCustomCreateCacheCallback ? new Func <ICache <long, long> >(CreatePerTenantCache) : null);
// Populate the cache
PopulateCache(cache);
cache.ClearAll();
SetTenant(Tenant1Id);
// Verify that the cache is empty for tenant 1
Assert.AreEqual(0, cache.Count);
// Verify that the cache is empty for tenant 2
SetTenant(Tenant2Id);
Assert.AreEqual(0, cache.Count);
}
public void GetEnumeratorIEnumerableTest(bool useCustomCreateCacheCallback)
{
int count;
var cache = new PerTenantNonSharingCache <long, long>("Test Cache", useCustomCreateCacheCallback ? new Func <ICache <long, long> >(CreatePerTenantCache) : null);
// Populate the cache
PopulateCache(cache);
// Verify that the entries are valid for tenant 1
SetTenant(Tenant1Id);
Assert.AreEqual(_tenant1Values.Count, cache.Count);
IEnumerator ten1Enumerator = ((IEnumerable)cache).GetEnumerator();
count = 0;
while (ten1Enumerator.MoveNext())
{
KeyValuePair <long, long> item = (KeyValuePair <long, long>)ten1Enumerator.Current;
Assert.AreEqual(1, _tenant1Values.Count(t => t.Item1 == item.Key && t.Item2 == item.Value));
count++;
}
Assert.AreEqual(_tenant1Values.Count, count);
// Verify that the entries are valid for tenant 2
SetTenant(Tenant2Id);
Assert.AreEqual(_tenant2Values.Count, cache.Count);
IEnumerator ten2Enumerator = ((IEnumerable)cache).GetEnumerator();
count = 0;
while (ten2Enumerator.MoveNext())
{
KeyValuePair <long, long> item = (KeyValuePair <long, long>)ten2Enumerator.Current;
Assert.AreEqual(1, _tenant2Values.Count(t => t.Item1 == item.Key && t.Item2 == item.Value));
count++;
}
Assert.AreEqual(_tenant2Values.Count, count);
}
public void TestTryGetOrAdd(bool useCustomCreateCacheCallback)
{
var cache = new PerTenantNonSharingCache <long, long>("Test Cache", useCustomCreateCacheCallback ? new Func <ICache <long, long> >(CreatePerTenantCache) : null);
long [] ids = new long [] { Tenant1Id, Tenant2Id };
foreach (long tenantId in ids)
{
long expectedValue = tenantId * 13;
SetTenant(tenantId);
/////
// Add a single element.
/////
long value;
bool result = cache.TryGetOrAdd(1, out value, key =>
{
Assert.That(key, Is.EqualTo(1));
return(expectedValue);
});
Assert.That(result, Is.False);
Assert.That(value, Is.EqualTo(expectedValue));
/////
// Request the same again
/////
result = cache.TryGetOrAdd(1, out value, key =>
{
throw new InvalidOperationException("The factory should not be called here");
});
Assert.That(result, Is.True);
Assert.That(value, Is.EqualTo(expectedValue));
}
}
