public void PoisonDisposesTheCache()
{
var mock = new MockDataRetriever();
var cache = new ResultCache <string>(Key, mock.GetData, GetCache());
cache.Get();
Assert.Equal(1, mock.DataRetrievalCount);
cache.Poison();
cache.Get();
Assert.Equal(2, mock.DataRetrievalCount);
}
public void GetEmptyResultFromCache()
{
ResultCache sut = new ResultCache();
ProcessingResult cachedResultUser1 = sut.Get("testUser1");
sut.Set("testUser3", new ProcessingResult());
ProcessingResult cachedResultUser2 = sut.Get("testUser2");
Assert.Null(cachedResultUser1);
Assert.Null(cachedResultUser2);
}
public void GetResultFromCacheAfterInitialAdd()
{
ResultCache sut = new ResultCache();
ProcessingResult resultUser1 = new ProcessingResult();
ProcessingResult resultUser2 = new ProcessingResult();
sut.Set("testUser1", resultUser1);
sut.Set("testUser2", resultUser2);
ProcessingResult cachedResultUser1 = sut.Get("testUser1");
ProcessingResult cachedResultUser2 = sut.Get("testUser2");
Assert.Equal(resultUser1, cachedResultUser1);
Assert.Equal(resultUser2, cachedResultUser2);
}
public async Task CachedDataIsRetrievedOnSubsequentUse()
{
var mock = new MockDataRetriever();
var cache = new ResultCache <string>(Key, mock.GetData, GetCache());
var result1 = await cache.Get();
var result2 = await cache.Get();
var result3 = await cache.Get();
var result4 = await cache.Get();
var result5 = await cache.Get();
Assert.Equal(1, mock.DataRetrievalCount);
Assert.True(new[] { result1, result2, result3, result4, result5 }.All(o => o.Equals("this is the data")));
}
public async Task ResultFailReturnsDefaultObject()
{
var mock = new MockDataRetriever();
var cache = new ResultCache <string>(Key, mock.GetFailData, GetCache());
var result = await cache.Get();
Assert.Null(result);
}
public async Task DataIsRetrievedOnceOnFirstTimeUse()
{
var mock = new MockDataRetriever();
var cache = new ResultCache <string>(Key, mock.GetData, GetCache());
var cachedData = await cache.Get();
Assert.Equal(1, mock.DataRetrievalCount);
Assert.Equal("this is the data", cachedData);
}
public void GetResultFromCacheAfterRewrite()
{
ResultCache sut = new ResultCache();
ProcessingResult result1 = new ProcessingResult();
sut.Set("testUser", result1);
ProcessingResult cachedResult1 = sut.Get("testUser");
Assert.Equal(result1, cachedResult1);
ProcessingResult Result = new ProcessingResult();
sut.Set("testUser", Result);
ProcessingResult cachedResult2 = sut.Get("testUser");
Assert.Equal(Result, cachedResult2);
}
public async Task SeperateInstancesWithSameKey()
{
var mock = new MockDataRetriever();
var cache = new ResultCache <string>(Key, mock.GetData, GetCache());
var cache2 = new ResultCache <string>(Key, mock.GetData, GetCache());
var result1 = await cache.Get();
var result2 = await cache.Get();
var result3 = await cache.Get();
var result4 = await cache2.Get();
var result5 = await cache2.Get();
var result6 = await cache2.Get();
Assert.Equal(2, mock.DataRetrievalCount); // we expect 2 because the data will be re-retrieved when newing up the second instance
Assert.True(new[] { result1, result2, result3, result4, result5, result6 }.All(o => o.Equals("this is the data")));
}
public async Task WhenCacheIsEmptyItReRetrievesTheDataAndCachesIt()
{
var mock = new MockDataRetriever();
var underlyingCache = GetCache();
var cache = new ResultCache <string>(Key, mock.GetData, underlyingCache);
underlyingCache.Remove(Key);
var result1 = await cache.Get();
var result2 = await cache.Get();
var result3 = await cache.Get();
var result4 = await cache.Get();
var result5 = await cache.Get();
Assert.Equal(1, mock.DataRetrievalCount);
Assert.True(new[] { result1, result2, result3, result4, result5 }.All(o => o.Equals("this is the data")));
}
public async Task WhenCacheIsEmptyItReRetrievesTheData()
{
var mock = new MockDataRetriever();
var underlyingCache = GetCache();
var cache = new ResultCache <string>(Key, mock.GetData, underlyingCache);
underlyingCache.Remove(Key);
var cachedData = await cache.Get();
Assert.Equal(1, mock.DataRetrievalCount);
Assert.Equal("this is the data", cachedData);
}
