public async Task DeleteAsync <TResult>(Expression <Func <T, TResult> > expression)
{
var invocation = ProxiedMethodInvocationGenerator <T> .FromExpression(expression);
var key = invocation.GetHashString(_hashScramble);
var result = await _memcachedCluster.Delete(key);
}
public 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 SyncLookupHandler <ITestInterface>(implementation.Object, policyProvider.Object, cache.Object);
var invocationSignature = ProxiedMethodInvocationGenerator <ITestInterface> .FromExpression(a => a.AddNumbers(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 = lookupHandler.Lookup(invocationSignature);
policyProvider.VerifyAll();
cache.VerifyAll();
}
public 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 SyncLookupHandler <ITestInterface>(implementation.Object, policyProvider.Object, cache.Object);
var invocation = ProxiedMethodInvocationGenerator <ITestInterface> .FromExpression(a => a.AddNumbers(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.AddNumbers(1, 2)).Throws(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 = lookupHandler.Lookup(invocation);
policyProvider.VerifyAll();
implementation.VerifyAll();
cache.VerifyAll();
}
public async Task DeleteAsync <TResult>(Expression <Func <T, TResult> > expression)
{
await Task.Factory.StartNew(() =>
{
var invocation = ProxiedMethodInvocationGenerator <T> .FromExpression(expression);
var hash = invocation.GetHashString <T, TResult>();
_cache.Remove(hash);
});
}
public void TestParameterless()
{
var configuredMethod = GetConfiguredMethod <ITestInterface>(a => a.ParameterlessMethod());
var proxyContext = ProxiedMethodInvocationGenerator <ITestInterface> .FromExpression(a => a.ParameterlessMethod());
var matched = configuredMethod.IsMatch(proxyContext.Method, proxyContext.Parameters);
Assert.IsTrue(matched, "MethodConfig didn't match");
}
public async void TestEmptyCacheSyncronization()
{
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 SyncLookupHandler <ITestInterface>(implementation.Object, policyProvider.Object, cache.Object);
var invocation = ProxiedMethodInvocationGenerator <ITestInterface> .FromExpression(a => a.AddNumbers(1, 2));
var method = invocation.Method;
var parameters = invocation.Parameters;
const int implReturnValue = 3;
implementation.Setup(a => a.AddNumbers(1, 2)).Returns(implReturnValue);
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(() => {});
cache.Setup(a => a.StoreAsync(invocation, cachePolicy, implReturnValue)).Returns(() => cacheStoreTask);
const int taskCount = 10;
var tasks = new Task <int> [taskCount];
for (var i = 0; i < taskCount; i++)
{
var idx = i;
tasks[idx] = Task.Factory.StartNew(() =>
{
if (idx == (taskCount - 1))
{
cacheStoreTask.Start();
}
return(lookupHandler.Lookup(invocation));
});
}
await Task.WhenAll(tasks);
Assert.IsTrue(tasks.All(a => a.Result == implReturnValue));
implementation.Verify(a => a.AddNumbers(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 SyncLookupHandler <ITestInterface>(implementation.Object, policyProvider.Object, cache.Object);
var invocation = ProxiedMethodInvocationGenerator <ITestInterface> .FromExpression(a => a.AddNumbers(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.AddNumbers(1, 2)).Throws(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 = lookupHandler.Lookup(invocation);
await awaitableStoreTask;
return(res);
});
var result = await task;
Assert.AreEqual(result, cachedObject.Object);
policyProvider.VerifyAll();
cache.VerifyAll();
implementation.VerifyAll();
}
public async void TestDirectCallInvocationAsync()
{
var implementationMock = new Mock <ITestInterface>(MockBehavior.Strict);
implementationMock.Setup(a => a.AddNumbersAsync(1, 2)).ReturnsAsync(1 + 2);
var handlerMock = new Mock <IProxyHandler <ITestInterface> >(MockBehavior.Strict);
var proxiedMethodInvocation = ProxiedMethodInvocationGenerator <ITestInterface> .FromExpression(a => a.AddNumbersAsync(1, 2));
handlerMock.Setup(a => a.HandleAsync(proxiedMethodInvocation)).Returns(proxiedMethodInvocation.InvokeAsync(implementationMock.Object));
var sleipner = new SleipnerProxy <ITestInterface>(implementationMock.Object);
var proxiedObject = sleipner.WrapWith(handlerMock.Object);
var result = await proxiedObject.AddNumbersAsync(1, 2);
Assert.AreEqual(3, result);
}
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 static CachePolicy GetPolicy <T, TResult>(this ICachePolicyProvider <T> provider, Expression <Func <T, TResult> > expression) where T : class
{
var invocation = ProxiedMethodInvocationGenerator <T> .FromExpression(expression);
return(provider.GetPolicy(invocation));
}
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);
}
public static bool IsMatch <T, TResult>(this IConfiguredMethod <T> method, Expression <Func <T, TResult> > expression) where T : class
{
var request = ProxiedMethodInvocationGenerator <T> .FromExpression(expression);
return(method.IsMatch(request.Method, request.Parameters));
}
