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(); }