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