public void Get_InDist_SetMem()
{
// arrange
var cache = new Mock <IDistributedCache>();
const string obj = "blob";
var expectedBytes = Encoding.UTF8.GetBytes($"\"{obj}\"");
cache.Setup(m => m.Get("test")).Returns(expectedBytes);
var memory = new Mock <IMemoryCache>();
var entry = new Mock <ICacheEntry>();
memory.Setup(m => m.CreateEntry(It.IsAny <object>())).Returns(entry.Object);
var svc = new DualLayerCacheService(cache.Object, memory.Object, new NullLogger <DualLayerCacheService>(), _opts);
// act
var _ = svc.Get <string>("test");
// assert
cache.Verify(m => m.Get("test"));
cache.VerifyNoOtherCalls();
entry.VerifySet(m => m.Value = obj);
entry.VerifySet(m => m.AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(_opts.Value.DefaultMemoryExpirySeconds));
entry.Verify(m => m.Dispose());
object val;
memory.Verify(m => m.TryGetValue("test", out val));
memory.Verify(m => m.CreateEntry("test"));
memory.VerifyNoOtherCalls();
}
public void Set_OK()
{
// arrange
const string encoded = "\"blob\"";
var expectedBytes = Encoding.UTF8.GetBytes(encoded);
var cache = new Mock <IDistributedCache>();
var memory = new Mock <IMemoryCache>();
var entry = new Mock <ICacheEntry>();
memory.Setup(m => m.CreateEntry(It.IsAny <object>())).Returns(entry.Object);
var svc = new DualLayerCacheService(cache.Object, memory.Object, new NullLogger <DualLayerCacheService>(), _opts);
// act
const string obj = "blob";
var _ = svc.Set("test", _ => obj);
// assert
cache.Verify(m => m.Set("test", It.Is <byte[]>(x => x.SequenceEqual(expectedBytes)), It.IsAny <DistributedCacheEntryOptions>()));
cache.VerifyNoOtherCalls();
entry.VerifySet(m => m.Value = obj);
entry.VerifySet(m => m.AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(_opts.Value.DefaultMemoryExpirySeconds));
entry.Verify(m => m.Dispose());
entry.VerifyNoOtherCalls();
memory.Verify(m => m.CreateEntry("test"));
memory.VerifyNoOtherCalls();
}
public void Set_ExcessiveMemDurationCappedAtHalf_OK()
{
// arrange
const string encoded = "\"blob\"";
var expectedBytes = Encoding.UTF8.GetBytes(encoded);
var cache = new Mock <IDistributedCache>();
var memory = new Mock <IMemoryCache>();
var entry = new Mock <ICacheEntry>();
memory.Setup(m => m.CreateEntry(It.IsAny <object>())).Returns(entry.Object);
var svc = new DualLayerCacheService(cache.Object, memory.Object, new NullLogger <DualLayerCacheService>(),
new OptionsWrapper <CacheSettings>(new CacheSettings {
DefaultMemoryExpirySeconds = 60 * 60 * 24
}));
// act
var obj = "blob";
var _ = svc.Set("test", opts =>
{
opts.AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(12);
return(obj);
});
// assert
cache.Verify(m => m.Set("test", It.Is <byte[]>(x => x.SequenceEqual(expectedBytes)), It.IsAny <DistributedCacheEntryOptions>()));
cache.VerifyNoOtherCalls();
entry.VerifySet(m => m.Value = obj);
entry.VerifySet(m => m.AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(6));
entry.Verify(m => m.Dispose());
entry.VerifyNoOtherCalls();
memory.Verify(m => m.CreateEntry("test"));
memory.VerifyNoOtherCalls();
}
public async Task SetAsync_Generic_OK()
{
// arrange
const string encoded = "{\"Id\":1,\"Name\":\"Test\"}";
var expectedBytes = Encoding.UTF8.GetBytes(encoded);
var cache = new Mock <IDistributedCache>();
var memory = new Mock <IMemoryCache>();
var entry = new Mock <ICacheEntry>();
memory.Setup(m => m.CreateEntry(It.IsAny <object>())).Returns(entry.Object);
var svc = new DualLayerCacheService(cache.Object, memory.Object, new NullLogger <DualLayerCacheService>(), _opts);
// act
var obj = new MyClass {
Id = 1, Name = "Test"
};
var _ = await svc.SetAsync("test", _ => Task.FromResult(obj));
// assert
cache.Verify(m => m.SetAsync("test", It.Is <byte[]>(x => x.SequenceEqual(expectedBytes)), It.IsAny <DistributedCacheEntryOptions>(), It.IsAny <CancellationToken>()));
cache.VerifyNoOtherCalls();
entry.VerifySet(m => m.Value = obj);
entry.VerifySet(m => m.AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(_opts.Value.DefaultMemoryExpirySeconds));
entry.Verify(m => m.Dispose());
entry.VerifyNoOtherCalls();
memory.Verify(m => m.CreateEntry("test"));
memory.VerifyNoOtherCalls();
}
public async Task GetOrCreateAsync_OK()
{
// arrange
const string encoded = "\"blob\"";
var expectedBytes = Encoding.UTF8.GetBytes(encoded);
var cache = new Mock <IDistributedCache>();
cache.Setup(m => m.GetAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync((byte[])null);
var memory = new Mock <IMemoryCache>();
var entry = new Mock <ICacheEntry>();
memory.Setup(m => m.CreateEntry(It.IsAny <object>())).Returns(entry.Object);
var svc = new DualLayerCacheService(cache.Object, memory.Object, new NullLogger <DualLayerCacheService>(), _opts);
// act
const string obj = "blob";
var _ = await svc.GetOrCreateAsync("test", _ => Task.FromResult(obj));
// assert
cache.Verify(m => m.GetAsync("test", It.IsAny <CancellationToken>()));
cache.Verify(m => m.SetAsync("test", It.Is <byte[]>(x => x.SequenceEqual(expectedBytes)), It.IsAny <DistributedCacheEntryOptions>(), It.IsAny <CancellationToken>()));
cache.VerifyNoOtherCalls();
entry.VerifySet(m => m.Value = obj);
entry.VerifySet(m => m.AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(_opts.Value.DefaultMemoryExpirySeconds));
entry.Verify(m => m.Dispose());
entry.VerifyNoOtherCalls();
object val;
memory.Verify(m => m.TryGetValue("test", out val));
memory.Verify(m => m.CreateEntry("test"));
memory.VerifyNoOtherCalls();
}
public async Task GetOrCreateAsync_Generic_OK()
{
// arrange
const string encoded = "{\"Id\":1,\"Name\":\"Test\"}";
var expectedBytes = Encoding.UTF8.GetBytes(encoded);
var cache = new Mock <IDistributedCache>();
cache.Setup(m => m.GetAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync((byte[])null);
var memory = new Mock <IMemoryCache>();
var logger = new Mock <ILogger <DualLayerCacheService> >();
logger.Setup(m => m.IsEnabled(LogLevel.Trace)).Returns(true);
var entry = new Mock <ICacheEntry>();
memory.Setup(m => m.CreateEntry(It.IsAny <object>())).Returns(entry.Object);
var svc = new DualLayerCacheService(cache.Object, memory.Object, logger.Object, _opts);
const string key = "test";
// act
var obj = new MyClass {
Id = 1, Name = "Test"
};
var _ = await svc.GetOrCreateAsync(key, opts =>
{
opts.AbsoluteExpirationRelativeToNow = TimeSpan.FromDays(1);
return(Task.FromResult(obj));
});
// assert
cache.Verify(m => m.GetAsync(key, It.IsAny <CancellationToken>()));
cache.Verify(m => m.SetAsync(key, It.Is <byte[]>(x => x.SequenceEqual(expectedBytes)), It.IsAny <DistributedCacheEntryOptions>(), It.IsAny <CancellationToken>()));
cache.VerifyNoOtherCalls();
entry.VerifySet(m => m.Value = obj);
entry.VerifySet(m => m.AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(_opts.Value.DefaultMemoryExpirySeconds));
entry.Verify(m => m.Dispose());
entry.VerifyNoOtherCalls();
object val;
memory.Verify(m => m.TryGetValue(key, out val));
memory.Verify(m => m.CreateEntry(key));
memory.VerifyNoOtherCalls();
logger.Verify(m => m.IsEnabled(LogLevel.Trace));
logger.Verify(m => m.Log(LogLevel.Trace, It.IsAny <EventId>(),
It.Is <It.IsAnyType>((obj, t) => obj.ToString() == $"Distributed Cache operation requested ({CacheOperation.Get}) => {key}"),
null, (Func <It.IsAnyType, Exception, string>)It.IsAny <object>()));
logger.Verify(m => m.Log(LogLevel.Trace, It.IsAny <EventId>(),
It.Is <It.IsAnyType>((obj, t) => obj.ToString() == $"Distributed Cache operation requested ({CacheOperation.Set}) => {key}"),
null, (Func <It.IsAnyType, Exception, string>)It.IsAny <object>()));
logger.VerifyNoOtherCalls();
}
public async Task GetAsyncGeneric_Integration_OK()
{
// arrange
var cache = new MemoryDistributedCache(new OptionsWrapper <MemoryDistributedCacheOptions>(new MemoryDistributedCacheOptions()));
await cache.SetStringAsync("test", "{ \"Id\": 1, \"Name\": \"Test\" }");
var memory = new MemoryCache(new OptionsWrapper <MemoryCacheOptions>(new MemoryCacheOptions()));
var svc = new DualLayerCacheService(cache, memory, new NullLogger <DualLayerCacheService>(), _opts);
// act
var result = await svc.GetAsync <MyClass>("test");
// assert
result.ShouldNotBeNull();
result.Id.ShouldBe(1);
result.Name.ShouldBe("Test");
}
public void Get_InMem_SkipDistributed_OK()
{
// arrange
var cache = new Mock <IDistributedCache>();
var memory = new Mock <IMemoryCache>();
object val = "blob";
memory.Setup(m => m.TryGetValue("test", out val)).Returns(true);
var svc = new DualLayerCacheService(cache.Object, memory.Object, new NullLogger <DualLayerCacheService>(), _opts);
// act
var _ = svc.Get <string>("test");
// assert
cache.VerifyNoOtherCalls();
memory.Verify(m => m.TryGetValue("test", out val));
memory.VerifyNoOtherCalls();
}
public void Remove_OK()
{
// arrange
var cache = new Mock <IDistributedCache>();
var memory = new Mock <IMemoryCache>();
var entry = new Mock <ICacheEntry>();
memory.Setup(m => m.CreateEntry(It.IsAny <object>())).Returns(entry.Object);
var svc = new DualLayerCacheService(cache.Object, memory.Object, new NullLogger <DualLayerCacheService>(), _opts);
// act
svc.Remove("test");
// assert
cache.Verify(m => m.Remove("test"));
cache.VerifyNoOtherCalls();
memory.Verify(m => m.Remove("test"));
memory.VerifyNoOtherCalls();
}
public async Task GetOrCreateAsync_Generic_InMem_OK()
{
// arrange
var obj = new MyClass {
Id = 1, Name = "Test"
};
var o = (object)obj;
const string key = "test";
var cache = new Mock <IDistributedCache>();
cache.Setup(m => m.GetAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync((byte[])null);
var memory = new Mock <IMemoryCache>();
var logger = new Mock <ILogger <DualLayerCacheService> >();
logger.Setup(m => m.IsEnabled(LogLevel.Trace)).Returns(true);
var entry = new Mock <ICacheEntry>();
memory.Setup(m => m.CreateEntry(It.IsAny <object>())).Returns(entry.Object);
memory.Setup(m => m.TryGetValue(key, out o)).Returns(true);
var svc = new DualLayerCacheService(cache.Object, memory.Object, logger.Object, _opts);
// act
var _ = await svc.GetOrCreateAsync(key, _ => Task.FromResult(obj));
// assert
cache.VerifyNoOtherCalls();
entry.VerifyNoOtherCalls();
object val;
memory.Verify(m => m.TryGetValue(key, out val));
memory.VerifyNoOtherCalls();
logger.Verify(m => m.IsEnabled(LogLevel.Trace));
logger.Verify(m => m.Log(LogLevel.Trace, It.IsAny <EventId>(),
It.Is <It.IsAnyType>((obj, t) => obj.ToString() == $"Distributed Cache operation requested ({CacheOperation.Get}) => {key}"),
null, (Func <It.IsAnyType, Exception, string>)It.IsAny <object>()));
logger.Verify(m => m.Log(LogLevel.Trace, It.IsAny <EventId>(),
It.Is <It.IsAnyType>((obj, t) => obj.ToString() == $"Distributed Memory Cache Hit => {key}"),
null, (Func <It.IsAnyType, Exception, string>)It.IsAny <object>()));
logger.VerifyNoOtherCalls();
}
public void Get_OK()
{
// arrange
var cache = new Mock <IDistributedCache>();
var memory = new Mock <IMemoryCache>();
var entry = new Mock <ICacheEntry>();
memory.Setup(m => m.CreateEntry(It.IsAny <object>())).Returns(entry.Object);
var svc = new DualLayerCacheService(cache.Object, memory.Object, new NullLogger <DualLayerCacheService>(), _opts);
// act
var _ = svc.Get <string>("test");
// assert
cache.Verify(m => m.Get("test"));
cache.VerifyNoOtherCalls();
entry.VerifyNoOtherCalls();
object val;
memory.Verify(m => m.TryGetValue("test", out val));
memory.VerifyNoOtherCalls();
}
public async Task GetAsyncGeneric_OK()
{
// arrange
var cache = new Mock <IDistributedCache>();
var memory = new Mock <IMemoryCache>();
var entry = new Mock <ICacheEntry>();
memory.Setup(m => m.CreateEntry(It.IsAny <object>())).Returns(entry.Object);
var svc = new DualLayerCacheService(cache.Object, memory.Object, new NullLogger <DualLayerCacheService>(), _opts);
// act
var _ = await svc.GetAsync <MyClass>("test");
// assert
cache.Verify(m => m.GetAsync("test", It.IsAny <CancellationToken>()));
cache.VerifyNoOtherCalls();
entry.VerifyNoOtherCalls();
object val;
memory.Verify(m => m.TryGetValue("test", out val));
memory.VerifyNoOtherCalls();
}
