public void GetValue_WhenPoco_Success() { var op = new Mock <IOperationResult <Dictionary <string, object> > >(); //value is null var bucket = new Mock <IBucket>(); bucket.Setup(x => x.GetAsync <Dictionary <string, object> >(It.IsAny <string>())) .Returns(Task.FromResult(op.Object)); var provider = new Mock <ICouchbaseCacheBucketProvider>(); provider.Setup(x => x.GetBucket()).Returns(bucket.Object); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); var session = new CouchbaseSession(cache, "thesessionkey", new TimeSpan(0, 0, 10, 0), () => true, new LoggerFactory(), true); session.Set("thekeyforpoco", new Poco { Name = "jeff" }); var result = session.Get("thekeyforpoco"); Assert.Equal(ConvertToBytes(new Poco { Name = "jeff" }), result); }
public void TryGetValue_When_ByteArray_Return_ByteArray() { var op = new Mock <IOperationResult <Dictionary <string, object> > >(); //value is null var bucket = new Mock <IBucket>(); bucket.Setup(x => x.GetAsync <Dictionary <string, object> >(It.IsAny <string>())) .Returns(Task.FromResult(op.Object)); var provider = new Mock <ICouchbaseCacheBucketProvider>(); provider.Setup(x => x.GetBucket()).Returns(bucket.Object); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); var session = new CouchbaseSession(cache, "thesessionkey", new TimeSpan(0, 0, 10, 0), () => true, new LoggerFactory(), true); var poco = ConvertToBytes(new Poco { Name = "jeff" }); session.Set("Set_Tests", poco); byte[] actual; var result = session.TryGetValue("Set_Tests", out actual); Assert.True(result); Assert.Same(poco, actual); }
public void Remove_Success() { var op = new Mock <IOperationResult <Dictionary <string, object> > >(); //value is null var bucket = new Mock <IBucket>(); bucket.Setup(x => x.GetAsync <Dictionary <string, object> >(It.IsAny <string>())) .Returns(Task.FromResult(op.Object)); var provider = new Mock <ICouchbaseCacheBucketProvider>(); provider.Setup(x => x.GetBucket()).Returns(bucket.Object); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); var session = new CouchbaseSession(cache, "thesessionkey", new TimeSpan(0, 0, 10, 0), () => true, new LoggerFactory(), true); var poco = new Poco { Name = "jeff" }; session.Set("remove_success", poco); Assert.Contains("remove_success", session.Keys.Cast <string>()); session.Remove("remove_success"); Assert.DoesNotContain("remove_success", session.Keys.Cast <string>()); }
public void Clear_Test() { var op = new Mock <IOperationResult <Dictionary <string, object> > >(); //value is null var bucket = new Mock <IBucket>(); bucket.Setup(x => x.GetAsync <Dictionary <string, object> >(It.IsAny <string>())) .Returns(Task.FromResult(op.Object)); var provider = new Mock <ICouchbaseCacheBucketProvider>(); provider.Setup(x => x.GetBucket()).Returns(bucket.Object); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); var session = new CouchbaseSession(cache, "thesessionkey", new TimeSpan(0, 0, 10, 0), () => true, new LoggerFactory(), true); var poco = new Poco { Name = "jeff" }; session.Set("Clear_Test", poco); Assert.NotEmpty(session.Keys); session.Clear(); Assert.Empty(session.Keys); }
public void TryGetValueOfT_Poco_Success() { var op = new Mock <IOperationResult <Dictionary <string, object> > >(); //value is null var bucket = new Mock <IBucket>(); bucket.Setup(x => x.GetAsync <Dictionary <string, object> >(It.IsAny <string>())) .Returns(Task.FromResult(op.Object)); var provider = new Mock <ICouchbaseCacheBucketProvider>(); provider.Setup(x => x.GetBucket()).Returns(bucket.Object); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); var session = new CouchbaseSession(cache, "thesessionkey", new TimeSpan(0, 0, 10, 0), () => true, new LoggerFactory(), true); var poco = new Poco { Name = "jeff" }; session.Set("thekey", poco); Poco value; var result = session.TryGetValue("thekey", out value); Assert.True(result); Assert.Same(poco, value); }
public void SetOfT_Test() { var op = new Mock <IOperationResult <Dictionary <string, byte[]> > >(); //value is null var bucket = new Mock <IBucket>(); bucket.Setup(x => x.GetAsync <Dictionary <string, byte[]> >(It.IsAny <string>())) .Returns(Task.FromResult(op.Object)); var provider = new Mock <ICouchbaseCacheBucketProvider>(); provider.Setup(x => x.GetBucket()).Returns(bucket.Object); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); var session = new CouchbaseSession(cache, "thesessionkey", new TimeSpan(0, 0, 10, 0), TimeSpan.Zero, () => true, new LoggerFactory(), true); var poco = new Poco { Name = "jeff" }; session.Set("SetOfT_Tests", poco); Poco actual; var result = session.TryGetValue("SetOfT_Tests", out actual); Assert.True(result); Assert.Equal(poco.Name, actual.Name); }
public async Task GetAsynct_Generic_WhenKeyIsNull_ThrowArgumentNullException() { var provider = new Mock <ICouchbaseCacheBucketProvider>(); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); await Assert.ThrowsAsync <ArgumentNullException>(async() => await cache.GetAsync <Poco>(null, new DistributedCacheEntryOptions())); }
public void Get_Generic_WhenKeyIsNull_ThrowArgumentNullException() { var provider = new Mock <ICouchbaseCacheBucketProvider>(); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); Assert.Throws <ArgumentNullException>(() => cache.Get <Poco>(null, new DistributedCacheEntryOptions())); }
public void Get_WhenKeyIsNull_ThrowArgumentNullException() { var provider = new Mock <ICouchbaseCacheCollectionProvider>(); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); Assert.Throws <ArgumentNullException>(() => cache.Get(null)); }
public async Task SetAsync_WhenKeyIsNull_ThrowArgumentNullException() { var provider = new Mock <ICouchbaseCacheCollectionProvider>(); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); await Assert.ThrowsAsync <ArgumentNullException>(async() => await cache.SetAsync(null, new byte[0], null)); }
public void Set_WhenValueIsNull_ThrowArgumentNullException() { var provider = new Mock <ICouchbaseCacheBucketProvider>(); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); Assert.Throws <ArgumentNullException>(() => cache.Set(null, new byte[0], null)); }
public async Task RemoveAsync_WhenKeyIsNull_ThrowArgumentNullException() { var provider = new Mock <ICouchbaseCacheBucketProvider>(); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); await Assert.ThrowsAsync <ArgumentNullException>(async() => await cache.RemoveAsync(null)); }
public void Set_WhenKeyIsNull_ThrowArgumentNullException() { var provider = new Mock <ICouchbaseCacheCollectionProvider>(); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); Assert.Throws <ArgumentNullException>(() => cache.Set(null, new byte[0], new DistributedCacheEntryOptions())); }
public void Remove_WhenKeyIsNull_ThrowArgumentNullException() { var provider = new Mock <ICouchbaseCacheBucketProvider>(); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); Assert.Throws <ArgumentNullException>(() => cache.Remove(null)); }
public void Test_GetLifeTime_When_Options_Null_Default_SlidingExpiration_Used() { var provider = new Mock <ICouchbaseCacheBucketProvider>(); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); var result = CouchbaseCacheExtensions.GetLifetime(cache); Assert.Equal(result, TimeSpan.FromMinutes(20)); }
public void Test_GetLifeTime_AbsoluteExpiration() { var provider = new Mock <ICouchbaseCacheBucketProvider>(); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); var absoluteExpiration = DateTime.UtcNow.AddDays(1); var result = CouchbaseCacheExtensions.GetLifetime(cache, new DistributedCacheEntryOptions { AbsoluteExpiration = new DateTimeOffset(absoluteExpiration) }); Assert.Equal(new DateTime(result.Ticks), absoluteExpiration); }
public void Test_GetLifeTime_SlidingExpiration() { var provider = new Mock <ICouchbaseCacheBucketProvider>(); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); var slidingExpiration = TimeSpan.FromSeconds(10); var result = CouchbaseCacheExtensions.GetLifetime(cache, new DistributedCacheEntryOptions { SlidingExpiration = slidingExpiration }); output.WriteLine(new DateTime(result.Ticks).ToString(CultureInfo.InvariantCulture)); Assert.Equal(new DateTime(result.Ticks), new DateTime(slidingExpiration.Ticks)); }
public void Test_GetLifeTime_AbsoluteExpirationRelativeToNow() { var provider = new Mock <ICouchbaseCacheBucketProvider>(); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); var absoluteExpirationRelativeToNow = TimeSpan.FromDays(1); var result = CouchbaseCacheExtensions.GetLifetime(cache, new DistributedCacheEntryOptions { AbsoluteExpirationRelativeToNow = absoluteExpirationRelativeToNow }); output.WriteLine(new DateTime(result.Ticks).ToShortDateString()); Assert.Equal(new DateTime(result.Ticks).ToShortDateString(), DateTime.UtcNow.AddTicks(absoluteExpirationRelativeToNow.Ticks).ToShortDateString()); }
public async Task LoadAsync_When_Cache_ThrowsException_BackingStore_Session_IsAvailable_False() { var bucket = new Mock <IBucket>(); bucket.Setup(x => x.GetAsync <Dictionary <string, object> >(It.IsAny <string>())) .Throws(new BucketNotFoundException()); var provider = new Mock <ICouchbaseCacheBucketProvider>(); provider.Setup(x => x.GetBucket()).Returns(bucket.Object); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); var session = new CouchbaseSession(cache, "thekey", new TimeSpan(0, 0, 10, 0), () => true, new LoggerFactory(), true); await session.LoadAsync(); Assert.False(session.IsAvailable); }
public void Test_GetLifeTime_AbsoluteExpirationRelativeToNow() { var provider = new Mock <ICouchbaseCacheCollectionProvider>(); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); var now = DateTime.UtcNow; var timerIncrement = 15; var absoluteExpirationRelativeToNow = TimeSpan.FromMinutes(timerIncrement); var result = CouchbaseCacheExtensions.GetLifetime(cache, new DistributedCacheEntryOptions { AbsoluteExpirationRelativeToNow = absoluteExpirationRelativeToNow }); Assert.Equal(absoluteExpirationRelativeToNow.Ticks, (long)Math.Round((double)result.Ticks / 1000000000) * 1000000000); }
public void Test_GetLifeTime_AbsoluteExpiration() { var provider = new Mock <ICouchbaseCacheBucketProvider>(); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); var now = DateTime.UtcNow; var timerIncrement = 1; var absoluteExpiration = now.AddDays(timerIncrement); var result = CouchbaseCacheExtensions.GetLifetime(cache, new DistributedCacheEntryOptions { AbsoluteExpiration = new DateTimeOffset(absoluteExpiration) }); Assert.Equal(TimeSpan.FromDays(timerIncrement).Ticks, (long)Math.Round((double)result.Ticks / 1000000000) * 1000000000); }
public async Task LoadAsync_When_Cache_DoesNotHave_BackingStore_Session_IsAvailable_True() { var op = new Mock <IOperationResult <Dictionary <string, object> > >(); //value is null var bucket = new Mock <IBucket>(); bucket.Setup(x => x.GetAsync <Dictionary <string, object> >(It.IsAny <string>())) .Returns(Task.FromResult(op.Object)); var provider = new Mock <ICouchbaseCacheBucketProvider>(); provider.Setup(x => x.GetBucket()).Returns(bucket.Object); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); var session = new CouchbaseSession(cache, "thekey", new TimeSpan(0, 0, 10, 0), () => true, new LoggerFactory(), true); await session.LoadAsync(); Assert.True(session.IsAvailable); }
public void TryGetValue_When_NotFound_Return_Null() { var op = new Mock <IOperationResult <Dictionary <string, byte[]> > >(); //value is null var bucket = new Mock <IBucket>(); bucket.Setup(x => x.GetAsync <Dictionary <string, byte[]> >(It.IsAny <string>())) .Returns(Task.FromResult(op.Object)); var provider = new Mock <ICouchbaseCacheBucketProvider>(); provider.Setup(x => x.GetBucket()).Returns(bucket.Object); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); var session = new CouchbaseSession(cache, "thesessionkey", new TimeSpan(0, 0, 10, 0), TimeSpan.Zero, () => true, new LoggerFactory(), true); byte[] actual; var result = session.TryGetValue("Set_Tests", out actual); Assert.False(result); Assert.Same(null, actual); }
public async Task LoadAsync_When_Cache_Has_BackingStore_Session_IsAvailable_True() { var op = new Mock <IOperationResult <Dictionary <string, byte[]> > >(); op.Setup(x => x.Value).Returns(new Dictionary <string, byte[]>()); var bucket = new Mock <IBucket>(); bucket.Setup(x => x.GetAndTouchAsync <Dictionary <string, byte[]> >(It.IsAny <string>(), It.IsAny <TimeSpan>())) .Returns(Task.FromResult(op.Object)); var provider = new Mock <ICouchbaseCacheBucketProvider>(); provider.Setup(x => x.GetBucket()).Returns(bucket.Object); var cache = new CouchbaseCache(provider.Object, new CouchbaseCacheOptions()); var session = new CouchbaseSession(cache, "thekey", new TimeSpan(0, 0, 10, 0), TimeSpan.Zero, () => true, new LoggerFactory(), true); await session.LoadAsync(CancellationToken.None); Assert.True(session.IsAvailable); }