public async void TestCachePolicyWithException()
{
var implementation = new Mock <ITestInterface>(MockBehavior.Strict);
var policyProvider = new Mock <ICachePolicyProvider <ITestInterface> >(MockBehavior.Strict);
var cache = new Mock <ICacheProvider <ITestInterface> >(MockBehavior.Strict);
var lookupHandler = new AsyncLookupHandler <ITestInterface>(implementation.Object, policyProvider.Object, cache.Object);
var invocationSignature = ProxiedMethodInvocationGenerator <ITestInterface> .FromExpression(a => a.AddNumbersAsync(1, 2));
var method = invocationSignature.Method;
var parameters = invocationSignature.Parameters;
var cachePolicy = new CachePolicy()
{
CacheDuration = 20
};
policyProvider.Setup(a => a.GetPolicy(method, parameters)).Returns(cachePolicy).Verifiable();
cache.Setup(a => a.GetAsync(invocationSignature, cachePolicy)).ReturnsAsync(new CachedObject <int>(CachedObjectState.Exception, new TestException())).Verifiable();
var result = await lookupHandler.LookupAsync(invocationSignature);
policyProvider.VerifyAll();
cache.VerifyAll();
}
public async void TestCachePolicyNoneException()
{
var implementation = new Mock <ITestInterface>(MockBehavior.Strict);
var policyProvider = new Mock <ICachePolicyProvider <ITestInterface> >(MockBehavior.Strict);
var cache = new Mock <ICacheProvider <ITestInterface> >(MockBehavior.Strict);
var lookupHandler = new AsyncLookupHandler <ITestInterface>(implementation.Object, policyProvider.Object, cache.Object);
var invocation = ProxiedMethodInvocationGenerator <ITestInterface> .FromExpression(a => a.AddNumbersAsync(1, 2));
var method = invocation.Method;
var parameters = invocation.Parameters;
var cachePolicy = new CachePolicy()
{
CacheDuration = 20
};
policyProvider.Setup(a => a.GetPolicy(method, parameters)).Returns(cachePolicy).Verifiable();
var exceptionThrown = new TestException();
implementation.Setup(a => a.AddNumbersAsync(1, 2)).ThrowsAsync(exceptionThrown).Verifiable();
cache.Setup(a => a.GetAsync(invocation, cachePolicy)).ReturnsAsync(new CachedObject <int>(CachedObjectState.None, null)).Verifiable();
cache.Setup(a => a.StoreExceptionAsync(invocation, cachePolicy, exceptionThrown)).Returns(Task.Factory.StartNew(() => { })).Verifiable();
var result = await lookupHandler.LookupAsync(invocation);
policyProvider.VerifyAll();
implementation.VerifyAll();
cache.VerifyAll();
}
public SleipnerCacheProxyHandler(T implementation, ICachePolicyProvider <T> cachePolicyProvider, ICacheProvider <T> cache)
{
_implementation = implementation;
_cachePolicyProvider = cachePolicyProvider;
_cache = cache;
_asyncLookupHandler = new AsyncLookupHandler <T>(_implementation, _cachePolicyProvider, _cache);
_syncLookupHandler = new SyncLookupHandler <T>(_implementation, _cachePolicyProvider, _cache);
_taskUpdateSyncronizer = new TaskSyncronizer();
}
public async void TestStaleCacheSyncronization()
{
var implementation = new Mock <ITestInterface>(MockBehavior.Strict);
var policyProvider = new Mock <ICachePolicyProvider <ITestInterface> >(MockBehavior.Strict);
var cache = new Mock <ICacheProvider <ITestInterface> >(MockBehavior.Strict);
var lookupHandler = new AsyncLookupHandler <ITestInterface>(implementation.Object, policyProvider.Object, cache.Object);
var invocation = ProxiedMethodInvocationGenerator <ITestInterface> .FromExpression(a => a.AddNumbersAsync(1, 2));
var method = invocation.Method;
var parameters = invocation.Parameters;
const int implReturnValue = 3;
implementation.Setup(a => a.AddNumbersAsync(1, 2)).ReturnsAsync(implReturnValue);
var cachePolicy = new CachePolicy()
{
CacheDuration = 20
};
policyProvider.Setup(a => a.GetPolicy(method, parameters)).Returns(cachePolicy);
const int cachedValue = 7;
var cachedObject = new CachedObject <int>(CachedObjectState.Stale, cachedValue);
cache.Setup(a => a.GetAsync(invocation, cachePolicy)).ReturnsAsync(cachedObject);
var cacheStoreTask = new Task(() => { });
cache.Setup(a => a.StoreAsync(invocation, cachePolicy, implReturnValue)).Returns(() =>
{
cacheStoreTask.Start();
return(cacheStoreTask);
});
const int taskCount = 10;
var tasks = new Task <int> [taskCount];
for (var i = 0; i < taskCount; i++)
{
tasks[i] = lookupHandler.LookupAsync(invocation);
}
await Task.WhenAll(tasks);
Assert.IsTrue(tasks.All(a => a.Result == cachedValue));
implementation.Verify(a => a.AddNumbersAsync(1, 2), Times.Once);
Assert.IsTrue(cacheStoreTask.Wait(5000), "Store action on cache did not appear to have been called");
cache.Verify(a => a.StoreAsync(invocation, cachePolicy, implReturnValue), Times.Once);
}
public async void TestCachePolicyStaleAsyncUpdateExceptionBubble()
{
var implementation = new Mock <ITestInterface>(MockBehavior.Strict);
var policyProvider = new Mock <ICachePolicyProvider <ITestInterface> >(MockBehavior.Strict);
var cache = new Mock <ICacheProvider <ITestInterface> >(MockBehavior.Strict);
var lookupHandler = new AsyncLookupHandler <ITestInterface>(implementation.Object, policyProvider.Object, cache.Object);
var invocation = ProxiedMethodInvocationGenerator <ITestInterface> .FromExpression(a => a.AddNumbersAsync(1, 2));
var method = invocation.Method;
var parameters = invocation.Parameters;
var cachePolicy = new CachePolicy()
{
CacheDuration = 20, BubbleExceptions = true
};
policyProvider.Setup(a => a.GetPolicy(method, parameters)).Returns(cachePolicy);
var cachedObject = new CachedObject <int>(CachedObjectState.Stale, 3);
cache.Setup(a => a.GetAsync(invocation, cachePolicy)).ReturnsAsync(cachedObject).Verifiable();
var thrownException = new TestException();
implementation.Setup(a => a.AddNumbersAsync(1, 2)).ThrowsAsync(thrownException).Verifiable();
var awaitableStoreTask = new Task(() => { });
cache.Setup(a => a.StoreExceptionAsync(invocation, cachePolicy, thrownException)).Returns(() =>
{
awaitableStoreTask.Start();
return(awaitableStoreTask);
}).Verifiable();
var task = await Task.Factory.StartNew(async() =>
{
var res = await lookupHandler.LookupAsync(invocation);
await awaitableStoreTask;
return(res);
});
var result = await task;
Assert.AreEqual(result, cachedObject.Object);
policyProvider.VerifyAll();
cache.VerifyAll();
implementation.VerifyAll();
}
public async void TestNoCachePolicyNull()
{
var implementation = new Mock <ITestInterface>(MockBehavior.Strict);
var policyProvider = new Mock <ICachePolicyProvider <ITestInterface> >(MockBehavior.Strict);
var cache = new Mock <ICacheProvider <ITestInterface> >(MockBehavior.Strict);
var lookupHandler = new AsyncLookupHandler <ITestInterface>(implementation.Object, policyProvider.Object, cache.Object);
var invocationSignature = ProxiedMethodInvocationGenerator <ITestInterface> .FromExpression(a => a.AddNumbersAsync(1, 2));
var method = invocationSignature.Method;
var parameters = invocationSignature.Parameters;
policyProvider.Setup(a => a.GetPolicy(method, parameters)).Returns(() => null).Verifiable();
implementation.Setup(a => a.AddNumbersAsync(1, 2)).ReturnsAsync(1 + 2).Verifiable();
await lookupHandler.LookupAsync(invocationSignature);
policyProvider.VerifyAll();
implementation.VerifyAll();
}
public async void TestEmptyCacheExceptionSyncronization()
{
var implementation = new Mock <ITestInterface>(MockBehavior.Strict);
var policyProvider = new Mock <ICachePolicyProvider <ITestInterface> >(MockBehavior.Strict);
var cache = new Mock <ICacheProvider <ITestInterface> >(MockBehavior.Strict);
var lookupHandler = new AsyncLookupHandler <ITestInterface>(implementation.Object, policyProvider.Object, cache.Object);
var invocation = ProxiedMethodInvocationGenerator <ITestInterface> .FromExpression(a => a.AddNumbersAsync(1, 2));
var method = invocation.Method;
var parameters = invocation.Parameters;
var thrownException = new TestException();
implementation.Setup(a => a.AddNumbersAsync(1, 2)).ThrowsAsync(thrownException);
var cachePolicy = new CachePolicy()
{
CacheDuration = 20
};
policyProvider.Setup(a => a.GetPolicy(method, parameters)).Returns(cachePolicy);
var cachedObject = new CachedObject <int>(CachedObjectState.None, null);
cache.Setup(a => a.GetAsync(invocation, cachePolicy)).ReturnsAsync(cachedObject);
var cacheStoreTask = new Task(() =>
{
Thread.Sleep(50);
});
cache.Setup(a => a.StoreExceptionAsync(invocation, cachePolicy, thrownException)).Returns(() =>
{
cacheStoreTask.Start();
return(cacheStoreTask);
});
const int taskCount = 10;
var tasks = new Task <int> [taskCount];
for (var i = 0; i < taskCount; i++)
{
tasks[i] = lookupHandler.LookupAsync(invocation);
}
foreach (var t in tasks)
{
try
{
await t;
Assert.Fail("Task didn't throw exception");
}
catch (TestException e)
{
}
}
implementation.Verify(a => a.AddNumbersAsync(1, 2), Times.Once);
Assert.IsTrue(cacheStoreTask.Wait(5000), "Store action on cache did not appear to have been called");
cache.Verify(a => a.StoreExceptionAsync(invocation, cachePolicy, thrownException), Times.Once);
}
