public void TestForConfigurationExtensions()
{
var instanceMock = new Mock<IAwesomeInterface>();
var cacheProviderMock = new Mock<ICacheProvider<IAwesomeInterface>>();
var sleipner = new SleipnerProxy<IAwesomeInterface>(instanceMock.Object, cacheProviderMock.Object);
sleipner.Config(a =>
{
a.For(b => b.ParameterlessMethod()).CacheFor(10);
a.For(b => b.ParameteredMethod(Param.IsAny<string>(), Param.IsAny<int>())).CacheFor(100).BubbleExceptionsWhenStale();
});
var parameterLessMethodInfo = typeof (IAwesomeInterface).GetMethod("ParameterlessMethod");
var parameteredMethodInfo = typeof(IAwesomeInterface).GetMethod("ParameteredMethod", new Type[] {typeof(string), typeof(int)});
var lolMethodInfo = typeof (IAwesomeInterface).GetMethod("LolMethod");
var parameterLessPolicy = sleipner.CachePolicyProvider.GetPolicy(parameterLessMethodInfo, new object[0]);
Assert.IsNotNull(parameterLessPolicy);
Assert.IsTrue(parameterLessPolicy.CacheDuration == 10);
Assert.IsFalse(parameterLessPolicy.BubbleExceptions);
var parameteredPolicy = sleipner.CachePolicyProvider.GetPolicy(parameteredMethodInfo, new object[2]);
Assert.IsNotNull(parameteredPolicy);
Assert.IsTrue(parameteredPolicy.CacheDuration == 100);
Assert.IsTrue(parameteredPolicy.BubbleExceptions);
var lolMethodPolicy = sleipner.CachePolicyProvider.GetPolicy(lolMethodInfo, new object[0]);
Assert.IsNull(lolMethodPolicy);
}
public void TestExceptionBubble()
{
var instanceMock = new Mock<IAwesomeInterface>();
var cacheProviderMock = new Mock<ICacheProvider<IAwesomeInterface>>();
var sleipner = new SleipnerProxy<IAwesomeInterface>(instanceMock.Object, cacheProviderMock.Object);
sleipner.Config(a =>
{
a.For(b => b.ParameterlessMethod()).CacheFor(10).BubbleExceptionsWhenStale();
});
var proxyContext = ProxyRequest<IAwesomeInterface>.FromExpression(a => a.ParameterlessMethod());
var cachePolicy = sleipner.CachePolicyProvider.GetPolicy(proxyContext.Method, proxyContext.Parameters);
var parameters = new object[0];
IEnumerable<string> result = new[] { "", "" };
var exception = new AwesomeException();
cacheProviderMock.Setup(a => a.GetItem(proxyContext, cachePolicy)).Returns(new CachedObject<IEnumerable<string>>(CachedObjectState.Stale, result));
instanceMock.Setup(a => a.ParameterlessMethod()).Throws(exception);
sleipner.Object.ParameterlessMethod();
Thread.Sleep(1000);
instanceMock.Verify(a => a.ParameterlessMethod(), Times.Once());
cacheProviderMock.Verify(a => a.GetItem(proxyContext, cachePolicy), Times.Once());
cacheProviderMock.Verify(a => a.StoreItem(proxyContext, cachePolicy, result), Times.Never());
cacheProviderMock.Verify(a => a.StoreException(proxyContext, cachePolicy, exception), Times.Once());
}
public void TestUnconfigured()
{
var instanceMock = new Mock<IAwesomeInterface>();
var cacheProviderMock = new Mock<ICacheProvider<IAwesomeInterface>>();
var sleipner = new SleipnerProxy<IAwesomeInterface>(instanceMock.Object, cacheProviderMock.Object);
var methods = typeof(IAwesomeInterface).GetMethods();
foreach (var method in methods)
{
var cachePolicy = sleipner.CachePolicyProvider.GetPolicy(method, method.GetParameters().Select(a => new object()));
Assert.IsNull(cachePolicy, "Sleipner returned a policy for: " + method.Name);
}
}
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 void TestDurationCache()
{
var instanceMock = new Mock<IAwesomeInterface>();
var cacheProvider = new DictionaryCache<IAwesomeInterface>();
var proxy = new SleipnerProxy<IAwesomeInterface>(instanceMock.Object, cacheProvider);
proxy.Config(a =>
{
a.DefaultIs().CacheFor(50);
});
var methodReturnValue = new[] {"", ""};
instanceMock.Setup(a => a.ParameteredMethod("", 0)).Returns(methodReturnValue);
proxy.Object.ParameteredMethod("", 0);
proxy.Object.ParameteredMethod("", 0);
proxy.Object.ParameteredMethod("", 0);
instanceMock.Verify(a => a.ParameteredMethod("", 0), Times.Once());
}
public void TestDefault()
{
var instanceMock = new Mock<IAwesomeInterface>();
var cacheProviderMock = new Mock<ICacheProvider<IAwesomeInterface>>();
var sleipner = new SleipnerProxy<IAwesomeInterface>(instanceMock.Object, cacheProviderMock.Object);
sleipner.Config(a =>
{
a.DefaultIs().CacheFor(10).BubbleExceptionsWhenStale();
});
var methods = typeof (IAwesomeInterface).GetMethods();
foreach (var method in methods)
{
var cachePolicy = sleipner.CachePolicyProvider.GetPolicy(method, method.GetParameters().Select(a => new object()));
Assert.IsNotNull(cachePolicy, "Sleipner did not create a cache policy for method: " + method.Name);
Assert.IsTrue(cachePolicy.CacheDuration == 10, "Sleiper did not create default policy with 10s duration for method: " + method.Name);
Assert.IsTrue(cachePolicy.BubbleExceptions, "Sleiper did not create default policy with bubble exceptions for method: " + method.Name);
}
}
public void TestDurationCache()
{
var instanceMock = new Mock <IAwesomeInterface>();
var cacheProvider = new DictionaryCache <IAwesomeInterface>();
var proxy = new SleipnerProxy <IAwesomeInterface>(instanceMock.Object, cacheProvider);
proxy.Config(a =>
{
a.DefaultIs().CacheFor(50);
});
var methodReturnValue = new[] { "", "" };
instanceMock.Setup(a => a.ParameteredMethod("", 0)).Returns(methodReturnValue);
proxy.Object.ParameteredMethod("", 0);
proxy.Object.ParameteredMethod("", 0);
proxy.Object.ParameteredMethod("", 0);
instanceMock.Verify(a => a.ParameteredMethod("", 0), Times.Once());
}
public void TestDefault()
{
var instanceMock = new Mock <IAwesomeInterface>();
var cacheProviderMock = new Mock <ICacheProvider <IAwesomeInterface> >();
var sleipner = new SleipnerProxy <IAwesomeInterface>(instanceMock.Object, cacheProviderMock.Object);
sleipner.Config(a =>
{
a.DefaultIs().CacheFor(10).BubbleExceptionsWhenStale();
});
var methods = typeof(IAwesomeInterface).GetMethods();
foreach (var method in methods)
{
var cachePolicy = sleipner.CachePolicyProvider.GetPolicy(method, method.GetParameters().Select(a => new object()));
Assert.IsNotNull(cachePolicy, "Sleipner did not create a cache policy for method: " + method.Name);
Assert.IsTrue(cachePolicy.CacheDuration == 10, "Sleiper did not create default policy with 10s duration for method: " + method.Name);
Assert.IsTrue(cachePolicy.BubbleExceptions, "Sleiper did not create default policy with bubble exceptions for method: " + method.Name);
}
}
public void TestGenericMethod()
{
var instanceMock = new Mock <IAwesomeInterface>();
var cacheProvider = new DictionaryCache <IAwesomeInterface>();
var proxy = new SleipnerProxy <IAwesomeInterface>(instanceMock.Object, cacheProvider);
proxy.Config(a =>
{
a.DefaultIs().CacheFor(50);
});
var methodReturnValue = new[] { "", "" }.ToList();
instanceMock.Setup(a => a.GenericMethod <string>("", 0)).Returns(methodReturnValue);
instanceMock.Setup(a => a.GenericMethod <object>("", 0)).Returns(new object[] { 1, 2 });
proxy.Object.GenericMethod <string>("", 0);
proxy.Object.GenericMethod <object>("", 0);
instanceMock.Verify(a => a.GenericMethod <string>("", 0), Times.Once());
}
public void It_should_not_make_duplicate_calls_while_cache_is_in_flight()
{
var cacheProvider = new DictionaryCache <IAwesomeInterface>();
var sleipnerProxy = new SleipnerProxy <IAwesomeInterface>(Mock.Object, cacheProvider);
sleipnerProxy.Config(a => { a.DefaultIs().CacheFor(10); });
var target = sleipnerProxy.Object;
var tasks = new[]
{
Task <IEnumerable <string> > .Factory.StartNew(() => target.ParameterlessMethod()),
Task <IEnumerable <string> > .Factory.StartNew(() => target.ParameterlessMethod()),
Task <IEnumerable <string> > .Factory.StartNew(() => target.ParameteredMethod("", 1)),
Task <IEnumerable <string> > .Factory.StartNew(() => target.ParameteredMethod("", 2)),
Task <IEnumerable <string> > .Factory.StartNew(() => target.ParameteredMethod("", 2)),
Task <IEnumerable <string> > .Factory.StartNew(() => target.ParameterlessMethod()),
Task <IEnumerable <string> > .Factory.StartNew(() => target.ParameterlessMethod()),
Task <IEnumerable <string> > .Factory.StartNew(() => target.ParameteredMethod("", 1, new[] { "1", "2", "3" })),
Task <IEnumerable <string> > .Factory.StartNew(() => target.ParameteredMethod("", 1, new[] { "1", "2", "3" })),
Task <IEnumerable <string> > .Factory.StartNew(() => target.ParameteredMethod("", 1, new[] { "1", "2", "3" })),
Task <IEnumerable <string> > .Factory.StartNew(() => target.ParameteredMethod("", 1, new[] { "1", "2", "3" })), //4 times
Task <IEnumerable <string> > .Factory.StartNew(() => target.ParameteredMethod("", 1, new[] { "d", "2", "3" })),
Task <IEnumerable <string> > .Factory.StartNew(() => target.ParameteredMethod("", 1, new[] { "d", "2", "3" })), //2 times
Task <IEnumerable <string> > .Factory.StartNew(() => target.ParameteredMethod("1", 1, new[] { "1", "2", "3" })),
Task <IEnumerable <string> > .Factory.StartNew(() => target.ParameteredMethod("1", 1, new[] { "1", "2", "3" })) //2 times
};
Task.WaitAll(tasks);
Mock.Verify(a => a.ParameterlessMethod(), Times.Exactly(1));
Mock.Verify(a => a.ParameteredMethod("", 1), Times.Exactly(1));
Mock.Verify(a => a.ParameteredMethod("", 2), Times.Exactly(1));
Mock.Verify(a => a.ParameteredMethod("", 1, new[] { "1", "2", "3" }), Times.Exactly(1));
Mock.Verify(a => a.ParameteredMethod("", 1, new[] { "d", "2", "3" }), Times.Exactly(1));
Mock.Verify(a => a.ParameteredMethod("1", 1, new[] { "1", "2", "3" }), Times.Exactly(1));
}
public void TestComplexParametersMethod()
{
var instanceMock = new Mock<IAwesomeInterface>();
var cacheProvider = new DictionaryCache<IAwesomeInterface>();
var proxy = new SleipnerProxy<IAwesomeInterface>(instanceMock.Object, cacheProvider);
proxy.Config(a =>
{
a.DefaultIs().CacheFor(50);
});
var methodReturnValue = new[] { "", "" }.ToList();
instanceMock.Setup(a => a.ParameteredMethod("a", 0, new [] { "a", "b" })).Returns(methodReturnValue);
instanceMock.Setup(a => a.ParameteredMethod("a", 0, new [] { "a", "c" })).Returns(methodReturnValue);
for (var i = 0; i <= 10; i++)
{
proxy.Object.ParameteredMethod("a", 0, new[] { "a", "b" });
proxy.Object.ParameteredMethod("a", 0, new[] { "a", "c" });
}
instanceMock.Verify(a => a.ParameteredMethod("a", 0, new[] { "a", "b" }), Times.Once());
instanceMock.Verify(a => a.ParameteredMethod("a", 0, new[] { "a", "c" }), Times.Once());
}
public void It_should_not_make_duplicate_calls_while_cache_is_in_flight()
{
var cacheProvider = new DictionaryCache<IAwesomeInterface>();
var sleipnerProxy = new SleipnerProxy<IAwesomeInterface>(Mock.Object, cacheProvider);
sleipnerProxy.Config(a => { a.DefaultIs().CacheFor(10); });
var target = sleipnerProxy.Object;
var tasks = new[]
{
Task<IEnumerable<string>>.Factory.StartNew(() => target.ParameterlessMethod()),
Task<IEnumerable<string>>.Factory.StartNew(() => target.ParameterlessMethod()),
Task<IEnumerable<string>>.Factory.StartNew(() => target.ParameteredMethod("", 1)),
Task<IEnumerable<string>>.Factory.StartNew(() => target.ParameteredMethod("", 2)),
Task<IEnumerable<string>>.Factory.StartNew(() => target.ParameteredMethod("", 2)),
Task<IEnumerable<string>>.Factory.StartNew(() => target.ParameterlessMethod()),
Task<IEnumerable<string>>.Factory.StartNew(() => target.ParameterlessMethod()),
Task<IEnumerable<string>>.Factory.StartNew(() => target.ParameteredMethod("", 1, new[] {"1", "2", "3"})),
Task<IEnumerable<string>>.Factory.StartNew(() => target.ParameteredMethod("", 1, new[] {"1", "2", "3"})),
Task<IEnumerable<string>>.Factory.StartNew(() => target.ParameteredMethod("", 1, new[] {"1", "2", "3"})),
Task<IEnumerable<string>>.Factory.StartNew(() => target.ParameteredMethod("", 1, new[] {"1", "2", "3"})), //4 times
Task<IEnumerable<string>>.Factory.StartNew(() => target.ParameteredMethod("", 1, new[] {"d", "2", "3"})),
Task<IEnumerable<string>>.Factory.StartNew(() => target.ParameteredMethod("", 1, new[] {"d", "2", "3"})), //2 times
Task<IEnumerable<string>>.Factory.StartNew(() => target.ParameteredMethod("1", 1, new[] {"1", "2", "3"})),
Task<IEnumerable<string>>.Factory.StartNew(() => target.ParameteredMethod("1", 1, new[] {"1", "2", "3"})) //2 times
};
Task.WaitAll(tasks);
Mock.Verify(a => a.ParameterlessMethod(), Times.Exactly(1));
Mock.Verify(a => a.ParameteredMethod("", 1), Times.Exactly(1));
Mock.Verify(a => a.ParameteredMethod("", 2), Times.Exactly(1));
Mock.Verify(a => a.ParameteredMethod("", 1, new[] {"1", "2", "3"}), Times.Exactly(1));
Mock.Verify(a => a.ParameteredMethod("", 1, new[] {"d", "2", "3"}), Times.Exactly(1));
Mock.Verify(a => a.ParameteredMethod("1", 1, new[] {"1", "2", "3"}), Times.Exactly(1));
}
public void TestStrangeGenericMethod_NoCache()
{
var instanceMock = new Mock<IAwesomeInterface>();
var cacheProvider = new DictionaryCache<IAwesomeInterface>();
var proxy = new SleipnerProxy<IAwesomeInterface>(instanceMock.Object, cacheProvider);
proxy.Config(a =>
{
a.DefaultIs().DisableCache();
});
var dictReturn = new Dictionary<string, int>()
{
{"a", 1},
{"b", 2},
{"c", 3},
};
instanceMock.Setup(a => a.StrangeGenericMethod("a", new[] { 1, 2, 3 })).Returns(dictReturn);
for (var i = 0; i < 10; i++)
{
var result = proxy.Object.StrangeGenericMethod("a", new[] { 1, 2, 3 });
Assert.AreSame(result, dictReturn);
}
instanceMock.Verify(a => a.StrangeGenericMethod("a", new[] { 1, 2, 3 }), Times.Exactly(10));
}
public static IContainer Initialize()
{
XmlConfigurator.Configure();
var useSecureCookie = ConfigurationManager.AppSettings["UseSecureCookie"] == "true";
var memcachedConfig = new MemcachedClientConfiguration
{
Protocol = MemcachedProtocol.Binary,
Transcoder = new NewtonsoftTranscoder()
};
memcachedConfig.AddServer("localhost", 11211);
MemcachedClient = new MemcachedClient(memcachedConfig);
var externalPartners = new List <Uri>
{
//new Uri("https://173.203.83.220/ssase12/services/users"), //Just here for testing.
new Uri("https://173.203.86.196/ssase12/services/users"),
new Uri("https://173.203.81.201/ssase12/services/users"),
new Uri("https://173.203.82.223/ssase12/services/users"),
new Uri("https://173.203.84.108/ssase12/services/users"),
new Uri("https://173.203.84.157/ssase12/services/users"),
new Uri("https://173.203.84.203/ssase12/services/users"),
new Uri("https://173.203.84.207/ssase12/services/users"),
new Uri("https://173.203.84.251/ssase12/services/users"),
new Uri("https://173.203.78.105/ssase12/services/users"),
new Uri("https://184.106.176.150/ssase12/services/users"),
new Uri("https://184.106.134.110/ssase12/services/users"),
new Uri("https://184.106.176.113/ssase12/services/users")
};
ExternalProfilesProxy = new SleipnerProxy <IExternalProfilesService>(
new RestApiExternalProfilesService(externalPartners),
new EnyimMemcachedProvider <IExternalProfilesService>(MemcachedClient)
);
ExternalProfilesProxy.Config(a => a.DefaultIs().CacheFor(60));
ObjectFactory.Initialize(x =>
{
x.For <IExternalProfilesService>()
.Use(ExternalProfilesProxy.Object);
x.For <IUserService>()
.Use <MongoUserService>();
x.For <IUserProfileService>()
.Use <MongoUserProfileService>();
x.For <IHugService>()
.Use <MongoHugService>();
x.For <IUserRepository>()
.Use <UserRepository>()
.Ctor <string>("connectionString").Is("mongodb://localhost/?safe=true")
.Ctor <string>("databaseName").Is("penedating");
x.For <IUserProfileRepository>()
.Use <UserProfileRepository>()
.Ctor <string>("connectionString").Is("mongodb://localhost/?safe=true")
.Ctor <string>("databaseName").Is("penedating");
x.For <IHugRepository>()
.Use <HugRepository>()
.Ctor <string>("connectionString").Is("mongodb://localhost/?safe=true")
.Ctor <string>("databaseName").Is("penedating");
x.For <IUserAccessTokenProvider>()
.Use <MemcachedAccessTokenProvider>()
.Ctor <string>("cookieName").Is("penedating-auth")
.Ctor <bool>("useSecureCookie").Is(useSecureCookie);
x.For <IMemcachedClient>().Use(MemcachedClient);
});
return(ObjectFactory.Container);
}
public void TestGenericMethod()
{
var instanceMock = new Mock<IAwesomeInterface>();
var cacheProvider = new DictionaryCache<IAwesomeInterface>();
var proxy = new SleipnerProxy<IAwesomeInterface>(instanceMock.Object, cacheProvider);
proxy.Config(a =>
{
a.DefaultIs().CacheFor(50);
});
var methodReturnValue = new[] { "", "" }.ToList();
instanceMock.Setup(a => a.GenericMethod<string>("", 0)).Returns(methodReturnValue);
instanceMock.Setup(a => a.GenericMethod<object>("", 0)).Returns(new object[] { 1, 2 });
proxy.Object.GenericMethod<string>("", 0);
proxy.Object.GenericMethod<object>("", 0);
instanceMock.Verify(a => a.GenericMethod<string>("", 0), Times.Once());
}
public T CreateCachedInstance()
{
var sleipnerProxy = new SleipnerProxy <T>(_implementation);
return(sleipnerProxy.WrapWith(_proxyHandler));
}
public void TestNoCache()
{
var instanceMock = new Mock<IAwesomeInterface>();
var cacheProvider = new DictionaryCache<IAwesomeInterface>();
var proxy = new SleipnerProxy<IAwesomeInterface>(instanceMock.Object, cacheProvider);
proxy.Config(a =>
{
a.DefaultIs().CacheFor(50);
a.For(b => b.ParameteredMethod(Param.IsAny<string>(), Param.IsAny<int>())).DisableCache();
});
var methodReturnValue = new[] { "", "" };
instanceMock.Setup(a => a.ParameteredMethod("", 0)).Returns(methodReturnValue);
instanceMock.Setup(a => a.ParameterlessMethod()).Returns(methodReturnValue);
proxy.Object.ParameteredMethod("", 0);
proxy.Object.ParameteredMethod("", 0);
proxy.Object.ParameteredMethod("", 0);
proxy.Object.ParameterlessMethod();
proxy.Object.ParameterlessMethod();
proxy.Object.ParameterlessMethod();
instanceMock.Verify(a => a.ParameteredMethod("", 0), Times.Exactly(3));
instanceMock.Verify(a => a.ParameterlessMethod(), Times.Once());
}
