public async Task LongRunningCacheTest_NoRefresh_InstantGet()
{
MemoryCacheWrapper memoryCache = new MemoryCacheWrapper(new MemoryCache(new MemoryCacheOptions()));
Mock <IDatabaseCache> databaseCache = new Mock <IDatabaseCache>();
LongRunningCache <int> longRunningCache = new LongRunningCache <int>(memoryCache, databaseCache.Object, TimeSpan.FromSeconds(2));
Debug.WriteLine("Starting...");
var result = await longRunningCache.GetOrRefreshCachedValueAsync("testKey", this.testRunner(), this.immediateValueGetter());
Debug.WriteLine(result.State);
Assert.IsTrue(result.State == CachedValueState.Updating);
await Task.Delay(1000);
result = await longRunningCache.GetOrRefreshCachedValueAsync("testKey", this.testRunner(), this.immediateValueGetter());
Debug.WriteLine(result.State);
Assert.IsTrue(result.State == CachedValueState.FoundAndNotUpdating);
await Task.Delay(3000);
result = await longRunningCache.GetOrRefreshCachedValueAsync("testKey", this.testRunner(), this.immediateValueGetter());
Debug.WriteLine("#3: " + result.State);
Assert.IsTrue(result.State == CachedValueState.Updating);
result = await longRunningCache.GetOrRefreshCachedValueAsync("testKey", this.testRunner(), this.immediateValueGetter());
await Task.Delay(500);
Debug.WriteLine("#4: " + result.State);
Assert.IsTrue(result.State == CachedValueState.FoundAndNotUpdating);
}
private void GetUserConnectionIdList_OnTryGetValueSuccess_ReturnsDictionary()
{
_memoryCache = MemoryCacheWrapper.GetMemoryCache(_dictionary, true);
_service = new MemoryAccess(_memoryCache);
Dictionary <string, object> result = _service.GetUserConnectionIdList();
Assert.Equal(_dictionary, result);
}
protected override void ConfigureTestServices(IServiceCollection services)
{
base.ConfigureTestServices(services);
IMemoryCache memoryCache = new MemoryCache(Options.Create(new MemoryCacheOptions()));
MemoryCacheWrapperFake = A.Fake <MemoryCacheWrapper>(opt => opt.WithArgumentsForConstructor(new object[] { memoryCache }).CallsBaseMethods());
services.AddSingleton(_ => memoryCache);
services.AddSingleton(_ => MemoryCacheWrapperFake);
}
private void GetUserConnectionIdList_OnTryGetValueFailed_ReturnsNewDictionary()
{
_memoryCache = MemoryCacheWrapper.GetMemoryCache(_dictionary, false);
Dictionary <string, object> expected = new Dictionary <string, object>();
_service = new MemoryAccess(_memoryCache);
Dictionary <string, object> result = _service.GetUserConnectionIdList();
Assert.Equal(expected, result);
}
public void CannotRetrieveCacheItemIfPolicyIsNotSet()
{
// arrange
const string key = "test";
var sut = new MemoryCacheWrapper <int>();
var act = new Action(() => sut.GetAsync(key).Wait());
// act
// assert
act.Should().Throw <InvalidOperationException>("Cache Policy has not been set");
}
private void GetGameList_OnTryGetValueSuccess_ReturnsDictionary()
{
_list = new List <GameStateModel> {
new GameStateModel(), new GameStateModel()
};
_memoryCache = MemoryCacheWrapper.GetMemoryCache(_list, true);
_service = new MemoryAccess(_memoryCache);
List <GameStateModel> result = _service.GetGameList();
Assert.Equal(_list, result);
}
public async Task LongRunningCacheTest_WithRefresh_WaitingGet()
{
MemoryCacheWrapper memoryCache = new MemoryCacheWrapper(new MemoryCache(new MemoryCacheOptions()));
Mock <IDatabaseCache> databaseCache = new Mock <IDatabaseCache>();
LongRunningCache <int> longRunningCache = new LongRunningCache <int>(memoryCache, databaseCache.Object, TimeSpan.FromSeconds(6), TimeSpan.FromSeconds(3));
DateTime startTime = DateTime.Now;
Debug.WriteLine("Starting...");
var result = await longRunningCache.GetOrRefreshCachedValueAsync("testKey", this.testRunner(), this.waitingValueGetter(500));
Debug.WriteLine("0.00: " + result.State);
Assert.IsTrue(result.State == CachedValueState.Updating);
await Task.Delay(250);
result = await longRunningCache.GetOrRefreshCachedValueAsync("testKey", this.testRunner(), this.waitingValueGetter(500));
Debug.WriteLine((DateTime.Now - startTime).TotalMilliseconds + ": " + result.State);
Assert.IsTrue(result.State == CachedValueState.Updating);
await Task.Delay(1000);
result = await longRunningCache.GetOrRefreshCachedValueAsync("testKey", this.testRunner(), this.waitingValueGetter(500));
Debug.WriteLine((DateTime.Now - startTime).TotalMilliseconds + ": " + result.State);
Assert.IsTrue(result.State == CachedValueState.FoundAndNotUpdating);
await Task.Delay(3000);
result = await longRunningCache.GetOrRefreshCachedValueAsync("testKey", this.testRunner(), this.waitingValueGetter(500));
Debug.WriteLine((DateTime.Now - startTime).TotalMilliseconds + ": " + result.State);
Assert.IsTrue(result.State == CachedValueState.FoundButUpdating);
await Task.Delay(1000);
result = await longRunningCache.GetOrRefreshCachedValueAsync("testKey", this.testRunner(), this.waitingValueGetter(500));
Debug.WriteLine((DateTime.Now - startTime).TotalMilliseconds + ": " + result.State);
Assert.IsTrue(result.State == CachedValueState.FoundAndNotUpdating);
await Task.Delay(10000);
result = await longRunningCache.GetOrRefreshCachedValueAsync("testKey", this.testRunner(), this.waitingValueGetter(500));
Debug.WriteLine((DateTime.Now - startTime).TotalMilliseconds + ": " + result.State);
Assert.IsTrue(result.State == CachedValueState.Updating);
}
public void CachePolicyCanOnlyBeSetOnce()
{
// arrange
var sut = new MemoryCacheWrapper <int>
{
CachePolicy = new CacheItemPolicy()
};
var act = new Action(() => sut.CachePolicy = new CacheItemPolicy());
// act
// assert
act.Should().Throw <InvalidOperationException>();
}
private void GetGameList_OnTryGetValueFailed_ReturnsNewDictionary()
{
_list = new List <GameStateModel> {
new GameStateModel(), new GameStateModel()
};
_memoryCache = MemoryCacheWrapper.GetMemoryCache(_list, false);
List <GameStateModel> expected = new List <GameStateModel>();
_service = new MemoryAccess(_memoryCache);
List <GameStateModel> result = _service.GetGameList();
Assert.Equal(expected, result);
}
public void DataRetrievalFuncCanOnlyBeSetOnce()
{
// arrange
var sut = new MemoryCacheWrapper <int>
{
DataRetrievalFunc = DataRetrievalFunc
};
var act = new Action(() => sut.DataRetrievalFunc = SecondRetrievalFunc);
// act
// assert
act.Should().Throw <InvalidOperationException>();
}
public async Task CheckingIfCacheContainsKeyWhenTheCacheDoesNotContainTheItemReturnsFalse()
{
// arrange
const string key = "test";
var cacheItemDummy = new CacheItemFixture();
var retrievalFixture = new RetrievalFixture <CacheItemFixture>(cacheItemDummy);
var sut = new MemoryCacheWrapper <CacheItemFixture>
{
CachePolicy = new CacheItemPolicy(),
DataRetrievalFunc = retrievalFixture.DataRetrievalFunc
};
// act
var result = await sut.ContainsKeyAsync(key);
// assert
result.Should().BeFalse();
}
public void AttemptToRemoveItemThatIsNotInTheCache()
{
// arrange
const string key = "test";
const int returnValue = 12;
var retrievalFixture = new RetrievalFixture <int>(returnValue);
var sut = new MemoryCacheWrapper <int>
{
CachePolicy = new CacheItemPolicy(),
DataRetrievalFunc = retrievalFixture.DataRetrievalFunc
};
// act
var removed = sut.RemoveFromCacheAsync(key).Result;
// assert
removed.Should().BeFalse();
}
public void RetrievingItemFromTheCacheReturnsTheCorrectItem()
{
// arrange
const string key = "test";
var cacheItemDummy = new CacheItemFixture();
var retrievalFixture = new RetrievalFixture <CacheItemFixture>(cacheItemDummy);
var sut = new MemoryCacheWrapper <CacheItemFixture>
{
CachePolicy = new CacheItemPolicy(),
DataRetrievalFunc = retrievalFixture.DataRetrievalFunc
};
var firstRetrieval = sut.GetAsync(key).Result;
// act
var secondRetrieval = sut.GetAsync(key).Result;
// assert
firstRetrieval.Should().Be(secondRetrieval);
}
public void AddItemToTheCache()
{
// arrange
const string key = "test";
const int returnValue = 12;
var retrievalFixture = new RetrievalFixture <int>(returnValue);
var sut = new MemoryCacheWrapper <int>
{
CachePolicy = new CacheItemPolicy(),
DataRetrievalFunc = retrievalFixture.DataRetrievalFunc
};
// act
var result = sut.GetAsync(key).Result;
// assert
sut.ItemsInCache.Should().Be(1);
retrievalFixture.WasCalled.Should().BeTrue();
result.Should().Be(returnValue);
}
public void MultipleRetrievalsOnlyHitTheRetrievalFuncitonOnce()
{
// arrange
const string key = "test";
const int returnValue = 12;
var retrievalFixture = new RetrievalFixture <int>(returnValue);
var sut = new MemoryCacheWrapper <int>
{
CachePolicy = new CacheItemPolicy(),
DataRetrievalFunc = retrievalFixture.DataRetrievalFunc
};
// act
Parallel.For(0, 10, t =>
{
sut.GetAsync(key).Wait();
});
// assert
retrievalFixture.CallCount.Should().Be(1);
}
public void RemoveItemFromCache()
{
// arrange
const string key = "test";
const int returnValue = 12;
var retrievalFixture = new RetrievalFixture <int>(returnValue);
var sut = new MemoryCacheWrapper <int>
{
CachePolicy = new CacheItemPolicy(),
DataRetrievalFunc = retrievalFixture.DataRetrievalFunc
};
sut.GetAsync(key).Wait();
// act
var removed = sut.RemoveFromCacheAsync(key).Result;
// assert
removed.Should().BeTrue();
sut.ItemsInCache.Should().Be(0);
}
private void UpdateGame_OnDifferentGameIds_AddsOneGameToTheListAndReturnsGame()
{
_list = new List <GameStateModel> {
new GameStateModel()
{
GameId = 3
}, new GameStateModel()
{
GameId = 4
}
};
_memoryCache = MemoryCacheWrapper.GetMemoryCache(_list, true);
_service = new MemoryAccess(_memoryCache);
GameStateModel game = new GameStateModel()
{
GameId = 1,
IsDeploymentAllowed = false,
IsStartAllowed = false,
Players = new Player[]
{
new Player()
{
UserName = "******"
},
new Player()
{
UserName = "******"
}
}
};
GameStateModel result = _service.UpdateGame(game);
Assert.NotNull(result);
Assert.Equal(3, _list.Count);
}
public FilmeController(MemoryCacheWrapper memoryCache, IOptions <SystemSettings> systemSettings, IFilmeServico filmeDominio)
{
_memoryCache = memoryCache;
_systemSettings = systemSettings.Value;
_filmeServico = filmeDominio;
}
public MemoryCacheWrapperTests()
{
_memoryCache = Substitute.For <IMemoryCache>();
_sut = new MemoryCacheWrapper(_memoryCache);
}
