public async Task Cache_Dist_Test_InMemoryPerformance()
{
// Arrange
var cacheAccessor1 = new CacheAccessor(new CacheConfig {
IsAuditingEnabled = true
});
var cacheAccessor2 = new CacheAccessor(new CacheConfig {
IsAuditingEnabled = true
});
await cacheAccessor1.InitialiseIfNecessaryAsync();
await cacheAccessor2.InitialiseIfNecessaryAsync();
var bigList = new List <int>(Enumerable.Range(0, 100000));
await cacheAccessor1.SetAsync("biglist", bigList);
var v1 = await cacheAccessor1.GetWithMetaDataAsync <List <int> >("biglist"); // should return instantly from the originating cache accessor (it's in-memory)
var v2 = await cacheAccessor2.GetWithMetaDataAsync <List <int> >("biglist"); // should return with some delay from the new cache accessor (it's on the central cache)
var v3 = await cacheAccessor2.GetWithMetaDataAsync <List <int> >("biglist"); // should return instantly, having put the object into in-memory cache the last time it was called
Assert.IsNotNull(v1.Data);
Assert.IsTrue(v1.IsFromInMemoryCache, "Shoulda oughta a bin from the in-memory cache");
Assert.IsNotNull(v2.Data);
Assert.IsTrue(v2.IsFromCentralCacheServer || v2.IsFromInMemoryCache, "Shoulda oughta a bin from the central / memory cache");
Assert.IsNotNull(v3.Data);
Assert.IsTrue(v3.IsFromInMemoryCache, "Shoulda oughta a bin from the in-memory cache");
}
public async Task Cache_NonDist_Test_That_Cache_Delete_Key_Works_OK()
{
// ARRANGE
var ca1 = new CacheAccessor(new CacheConfig {
IsAuditingEnabled = true, IsCentralCacheEnabled = false
});
await ca1.InitialiseIfNecessaryAsync();
var KEY = CreateGuid();
var VALUE = CreateGuid();
// ACT
await ca1.SetAsync(KEY, VALUE); // set the value
await ca1.DeleteAsync(KEY);
var evt1 = ca1.LastCachingEvent;
var v2 = await ca1.GetWithMetaDataAsync <string>(KEY);
// ASSERT
Assert.IsNull(v2.Data);
Assert.IsTrue(evt1 == eCacheEvent.KeyDeletedInMemory);
Assert.IsTrue(ca1.LastCachingEvent == eCacheEvent.KeyValueGotFromMemoryAttempt);
}
public async Task Cache_Dist_Test_That_Cache_Expiry_Works_OK()
{
// ARRANGE
var ca1 = new CacheAccessor(new CacheConfig {
IsAuditingEnabled = true
});
var ca2 = new CacheAccessor(new CacheConfig {
IsAuditingEnabled = true
});
await ca1.InitialiseIfNecessaryAsync();
await ca2.InitialiseIfNecessaryAsync();
var KEY = CreateGuid();
var VALUE = CreateGuid();
// ACT
await ca1.SetAsync(KEY, VALUE, TimeSpan.FromSeconds(5));
await ca2.WaitForEvent(eCacheEvent.KeySetInMemory);
var v1 = await ca2.GetWithMetaDataAsync <string>(KEY);
var v2 = await ca1.GetWithMetaDataAsync <string>(KEY);
await Task.Delay(5000);
var v3 = await ca2.GetWithMetaDataAsync <string>(KEY);
var v4 = await ca1.GetWithMetaDataAsync <string>(KEY);
Assert.IsNotNull(v1.Data);
Assert.IsNotNull(v2.Data);
Assert.IsTrue(v1.IsFromInMemoryCache);
Assert.IsTrue(v2.IsFromInMemoryCache);
Assert.IsNull(v3.Data);
Assert.IsNull(v4.Data);
Assert.IsTrue(v3.IsFromCentralCacheServer);
Assert.IsTrue(v4.IsFromCentralCacheServer);
}
public async Task Cache_Dist_Test_That_Cache_Delete_Key_Works_OK()
{
// ARRANGE
var ca1 = new CacheAccessor(new CacheConfig {
IsAuditingEnabled = true
});
var ca2 = new CacheAccessor(new CacheConfig {
IsAuditingEnabled = true
});
await ca1.InitialiseIfNecessaryAsync();
await ca2.InitialiseIfNecessaryAsync();
var KEY = CreateGuid();
var VALUE = CreateGuid();
// ACT
await ca1.SetAsync(KEY, VALUE); // set the value
// Wait for propagation to ca2
await ca2.WaitForEvent(eCacheEvent.KeySetInMemory);
var v1 = await ca2.GetWithMetaDataAsync <string>(KEY);
await ca2.DeleteAsync(KEY);
var propagationTimeInMS = await ca1.WaitForEvent(eCacheEvent.KeyDeletedInMemory);
var v2 = await ca1.GetWithMetaDataAsync <string>(KEY);
var v3 = await ca2.GetWithMetaDataAsync <string>(KEY);
// ASSERT
Assert.IsNotNull(v1.Data);
Assert.IsTrue(v1.IsFromInMemoryCache);
Assert.IsNull(v2.Data);
Assert.IsTrue(v2.IsFromCentralCacheServer);
Assert.IsNull(v3.Data);
Assert.IsTrue(v3.IsFromCentralCacheServer);
}
public async Task Cache_Dist_Test_Caching_Byte_Arrays()
{
// ARRANGE
var ca1 = new CacheAccessor(new CacheConfig {
IsAuditingEnabled = true
});
var ca2 = new CacheAccessor(new CacheConfig {
IsAuditingEnabled = true
});
await ca1.InitialiseIfNecessaryAsync();
await ca2.InitialiseIfNecessaryAsync();
var KEY1 = CreateGuid();
var VALUE1 = new byte[] { 32, 34, 55 };
var KEY2 = CreateGuid();
var VALUE2 = new byte[] { 1, 11, 33 };
// ACT
await ca1.SetAsync(KEY1, VALUE1); // set the value
await ca2.WaitForEvent(eCacheEvent.KeySetInMemory);
await ca2.SetAsync(KEY2, VALUE2); // set the value
await ca1.WaitForEvent(eCacheEvent.KeySetInMemory);
var data1 = await ca2.GetWithMetaDataAsync <byte[]>(KEY1);
var data2 = await ca1.GetWithMetaDataAsync <byte[]>(KEY2);
Assert.AreEqual(VALUE1.Length, data1.Data.Length);
Assert.AreEqual(VALUE2.Length, data2.Data.Length);
Assert.AreEqual(VALUE1[0], data1.Data[0]);
Assert.AreEqual(VALUE1[1], data1.Data[1]);
Assert.AreEqual(VALUE1[2], data1.Data[2]);
Assert.AreEqual(VALUE2[0], data2.Data[0]);
Assert.AreEqual(VALUE2[1], data2.Data[1]);
Assert.AreEqual(VALUE2[2], data2.Data[2]);
}
public async Task Cache_Dist_TestKeyValuePairPropagation()
{
// Arrange
var KEY = Key();
var VALUE = CreateGuid();
var cacheAccessor1 = new CacheAccessor(new CacheConfig {
IsAuditingEnabled = true
});
var cacheAccessor2 = new CacheAccessor(new CacheConfig {
IsAuditingEnabled = true
});
await cacheAccessor1.InitialiseIfNecessaryAsync();
await cacheAccessor2.InitialiseIfNecessaryAsync();
cacheAccessor1.AuditLog.Clear();
cacheAccessor2.AuditLog.Clear();
// Act
var v1 = await cacheAccessor1.GetWithMetaDataAsync <string>(KEY);
await cacheAccessor1.SetAsync(KEY, VALUE, TimeSpan.FromMinutes(2));
await Task.Delay(300);
var logOfCA2 = cacheAccessor2.AuditLog.ToArray();
var v2 = await cacheAccessor2.GetWithMetaDataAsync <string>(KEY);
var v3 = await cacheAccessor2.GetWithMetaDataAsync <string>(KEY);
var cacheAccessor3 = new CacheAccessor(new CacheConfig());
await cacheAccessor3.InitialiseIfNecessaryAsync();
var v6 = await cacheAccessor3.GetWithMetaDataAsync <string>(KEY);
var v7 = await cacheAccessor3.GetWithMetaDataAsync <string>(KEY);
await cacheAccessor2.DeleteAsync(KEY);
var v4_1 = await cacheAccessor1.GetWithMetaDataAsync <string>(KEY);
var v5_1 = await cacheAccessor2.GetWithMetaDataAsync <string>(KEY);
await Task.Delay(300);
var v4 = await cacheAccessor1.GetWithMetaDataAsync <string>(KEY);
var v5 = await cacheAccessor2.GetWithMetaDataAsync <string>(KEY);
Assert.IsTrue(logOfCA2.First().CachingEvent == eCacheEvent.KeySetInMemory, "The next audit event should have been to receive the key update message");
Assert.IsTrue(v1.IsFromCentralCacheServer, "Trying to get something that isn't set, should _AT_LEAST_ try the central cache");
Assert.IsTrue(v2.IsFromInMemoryCache, "Getting an item after setting it should mean that the in-memory cache has had time to catch up");
Assert.IsTrue(v3.IsFromInMemoryCache, "The value should have propagated to cache accessor");
Assert.IsNull(v4.Data, "The value should be null");
Assert.IsNull(v5.Data, "The value should be null");
Assert.IsTrue(v4.IsFromCentralCacheServer, "If a value is null, it should have tried the central cache server");
Assert.IsTrue(v5.IsFromCentralCacheServer, "If a value is null, it should have tried the central cache server");
Assert.IsNotNull(v6.Data, "The data shouldn't be null");
Assert.IsTrue(v6.IsFromCentralCacheServer, "The value should have been retrieved from the central server");
Assert.IsNotNull(v7.Data, "The data shouldn't be null");
Assert.AreEqual(VALUE, v7.Data);
Assert.IsTrue(v7.IsFromInMemoryCache, "The value should have been retrieved from the memory cache");
// This test is too subjective for the build server
// Assert.IsTrue(v7.ElapsedMilliseconds < v6.ElapsedMilliseconds, "It should have been quicker to get the value the second time");
}
