public void MemberBasedBindingOfTypeDependencies()
{
IModule module = new InlineModule(
m => m.Bind(typeof(ObjectWithMethodInterceptor)).ToSelf(),
m => m.Intercept(When.Request.Method.Name.StartsWith("F")).With<CountInterceptor>()
);
using (var kernel = new StandardKernel(module))
{
kernel.Components.Connect<IProxyFactory>(new DummyProxyFactory());
var obj = kernel.Get<ObjectWithMethodInterceptor>();
IContext context = kernel.Components.ContextFactory.Create(typeof(ObjectWithMethodInterceptor));
IRequest request = new StandardRequest(
context,
obj,
typeof(ObjectWithMethodInterceptor).GetMethod("Foo"),
new object[0],
Type.EmptyTypes
);
ICollection<IInterceptor> interceptors = kernel.Components.AdviceRegistry.GetInterceptors(request);
Assert.That(interceptors.Count, Is.EqualTo(2));
IEnumerator<IInterceptor> enumerator = interceptors.GetEnumerator();
enumerator.MoveNext();
Assert.That(enumerator.Current, Is.InstanceOfType(typeof(CountInterceptor)));
enumerator.MoveNext();
Assert.That(enumerator.Current, Is.InstanceOfType(typeof(CountInterceptor)));
}
}
public void ResultOfMethodCallWithSameArgumentsIsCached()
{
IModule testModule = new InlineModule(m => m.Bind<CacheMock>().ToSelf());
using (var kernel = new StandardKernel(new LinFuModule(), new CacheModule(), testModule))
{
var obj = kernel.Get<CacheMock>();
CacheMock.ResetCounts();
int result;
result = obj.Multiply(2, 3);
Assert.That(result, Is.EqualTo(6));
Assert.That(CacheMock.MultiplyCount, Is.EqualTo(1));
result = obj.Multiply(2, 3);
Assert.That(result, Is.EqualTo(6));
Assert.That(CacheMock.MultiplyCount, Is.EqualTo(1));
result = obj.Multiply(4, 4);
Assert.That(result, Is.EqualTo(16));
Assert.That(CacheMock.MultiplyCount, Is.EqualTo(2));
}
}
public void MemberBasedBindingOfTypeDependencies()
{
IModule module = new InlineModule(
m => m.Bind(typeof(IMock)).To(typeof(ImplA)).Only(When.Context.Member.Tag.EqualTo("A")),
m => m.Bind(typeof(IMock)).To(typeof(ImplB)).Only(When.Context.Member.Tag.EqualTo("B")),
m => m.Bind(typeof(IMock)).To(typeof(ImplC)).Only(!When.Context.Member.Tag.EqualTo("A") & !When.Context.Member.Tag.EqualTo("B"))
);
using (var kernel = new StandardKernel(module))
{
var obj1 = kernel.Get<RequestsTagA>();
Assert.That(obj1, Is.Not.Null);
Assert.That(obj1.Child, Is.Not.Null);
Assert.That(obj1.Child, Is.InstanceOfType(typeof(ImplA)));
var obj2 = kernel.Get<RequestsTagB>();
Assert.That(obj2, Is.Not.Null);
Assert.That(obj2.Child, Is.Not.Null);
Assert.That(obj2.Child, Is.InstanceOfType(typeof(ImplB)));
var obj3 = kernel.Get<RequestsNoTag>();
Assert.That(obj3, Is.Not.Null);
Assert.That(obj3.Child, Is.Not.Null);
Assert.That(obj3.Child, Is.InstanceOfType(typeof(ImplC)));
}
}
public void StaticInterceptorsAreRegisteredFromAttributesDefinedOnMethods()
{
var module = new InlineModule(m => m.Bind<ObjectWithMethodInterceptor>().ToSelf());
using (var kernel = new StandardKernel(module))
{
kernel.Components.Connect<IProxyFactory>(new DummyProxyFactory());
var obj = kernel.Get<ObjectWithMethodInterceptor>();
IContext context = kernel.Components.ContextFactory.Create(typeof(ObjectWithMethodInterceptor));
IRequest request = new StandardRequest(
context,
obj,
typeof(ObjectWithMethodInterceptor).GetMethod("Foo"),
new object[0],
Type.EmptyTypes
);
ICollection<IInterceptor> interceptors = kernel.Components.AdviceRegistry.GetInterceptors(request);
IEnumerator<IInterceptor> enumerator = interceptors.GetEnumerator();
enumerator.MoveNext();
Assert.That(interceptors.Count, Is.EqualTo(1));
Assert.That(enumerator.Current, Is.InstanceOfType(typeof(CountInterceptor)));
}
}
public void DefiningMultipleDefaultBindingsThrowsException()
{
var module = new InlineModule(
m => m.Bind(typeof(IMock)).To(typeof(ImplA)),
m => m.Bind(typeof(IMock)).To(typeof(ImplB))
);
var kernel = new StandardKernel(module);
}
public void HeuristicIgnoresParameterlessMethods()
{
var testModule = new InlineModule(m => m.Bind<PocoForMethodAutoWiring>().ToSelf());
using (var kernel = new StandardKernel(new AutoWiringModule(), testModule))
{
var mock = kernel.Get<PocoForMethodAutoWiring>();
Assert.That(mock, Is.Not.Null);
Assert.That(mock.ParameterlessMethodWasCalled, Is.False);
}
}
public void SelfBoundTypesDeclaringMethodInterceptorsAreProxied()
{
var testModule = new InlineModule(m => m.Bind<ObjectWithMethodInterceptor>().ToSelf());
using (var kernel = new StandardKernel(new DynamicProxy2Module(), testModule))
{
var obj = kernel.Get<ObjectWithMethodInterceptor>();
Assert.That(obj, Is.Not.Null);
Assert.That(obj, Is.InstanceOfType(typeof(IProxyTargetAccessor)));
}
}
public void SelfBoundTypesDeclaringMethodInterceptorsCanBeReleased()
{
var testModule = new InlineModule(m => m.Bind<ObjectWithMethodInterceptor>().ToSelf());
using (var kernel = new StandardKernel(new DynamicProxy2Module(), testModule))
{
var obj = kernel.Get<ObjectWithMethodInterceptor>();
Assert.That(obj, Is.Not.Null);
kernel.Release(obj);
}
}
public void CanBindToStaticFactoryMethodWithParameters()
{
var module = new InlineModule(
m => m.Bind(typeof(IMock)).ToMethod(ctx => MockFactory.CreateStatic("foo", 42))
);
using (var kernel = new StandardKernel(module))
{
var mock = kernel.Get<IMock>();
Assert.That(mock, Is.Not.Null);
Assert.That(mock, Is.InstanceOfType(typeof(ImplB)));
}
}
private static InlineModule GetRuntimeModule(IPlatform platform)
{
var module = new InlineModule(
m => m.Bind<IPlatform>().ToConstant(platform),
m => m.Bind<IDisplayDevice>().ToConstant(platform.DisplayDevice),
m => m.Bind<IMouseDevice>().ToConstant(platform.MouseDevice),
m => m.Bind<IFileLoader>().To(platform.FileLoaderType).Using<SingletonBehavior>(),
m => m.Bind<IGeometryContext>().To(platform.GeometryContextType),
m => m.Bind<ISpriteContext>().To(platform.SpriteContextType),
m => m.Bind<IImageContext>().To(platform.ImageContextType),
m => m.Bind<IShapeContext>().To(platform.ShapeContextType)
);
return module;
}
public void DebugInfoCreatedFromStackTrace()
{
var module = new InlineModule(m => m.Bind<IMock>().To<SimpleObject>());
var options = new KernelOptions { GenerateDebugInfo = true };
using (var kernel = new StandardKernel(options, module))
{
IContext context = kernel.Components.ContextFactory.Create(typeof(IMock));
IBinding binding = kernel.Components.BindingSelector.SelectBinding(typeof(IMock), context);
Assert.That(binding, Is.Not.Null);
Assert.That(binding.DebugInfo, Is.Not.Null);
}
}
public void ServiceBoundTypeReceivesFieldInjection()
{
var module = new InlineModule(m => m.Bind(typeof(IMock)).To(typeof(RequestsFieldInjection)));
using (var kernel = new StandardKernel(module))
{
var mock = kernel.Get<IMock>();
Assert.That(mock, Is.Not.Null);
var typedMock = mock as RequestsFieldInjection;
Assert.That(typedMock, Is.Not.Null);
Assert.That(typedMock.Child, Is.Not.Null);
}
}
public void CanBindGenericTypeDefinitions()
{
var module = new InlineModule(m => m.Bind(typeof(IGenericObject<>)).To(typeof(GenericImpl<>)));
using (var kernel = new StandardKernel(module))
{
Type type = typeof(IGenericObject<>);
IContext context = kernel.Components.ContextFactory.Create(type);
IBinding binding = kernel.Components.BindingSelector.SelectBinding(type, context);
Assert.That(binding, Is.Not.Null);
Assert.That(binding.Provider, Is.InstanceOfType(typeof(GenericProvider)));
}
}
public void ServiceBoundTypeReceivesMethodInjection()
{
var module = new InlineModule(m => m.Bind<IMock>().To<RequestsMethodInjection>());
using (var kernel = new StandardKernel(module))
{
var mock = kernel.Get<IMock>();
Assert.That(mock, Is.Not.Null);
var typedMock = mock as RequestsMethodInjection;
Assert.That(typedMock, Is.Not.Null);
Assert.That(typedMock.Child, Is.Not.Null);
Assert.That(typedMock.Child, Is.InstanceOfType(typeof(SimpleObject)));
}
}
public void CanBindToParameterlessInstanceFactoryMethod()
{
var factory = new MockFactory();
var module = new InlineModule(
m => m.Bind(typeof(IMock)).ToMethod(ctx => factory.Create())
);
using (var kernel = new StandardKernel(module))
{
var mock = kernel.Get<IMock>();
Assert.That(mock, Is.Not.Null);
Assert.That(mock, Is.InstanceOfType(typeof(ImplA)));
}
}
public void CanActivateGenericTypeViaGenericTypeDefinitionBindingWithSingletonBehavior()
{
var module = new InlineModule(m => m.Bind(typeof(IGenericObject<>)).To(typeof(GenericImpl<>)).Using<SingletonBehavior>());
using (var kernel = new StandardKernel(module))
{
var mock1 = kernel.Get<IGenericObject<string>>();
Assert.That(mock1, Is.Not.Null);
Assert.That(mock1, Is.InstanceOfType(typeof(GenericImpl<string>)));
var mock2 = kernel.Get<IGenericObject<int>>();
Assert.That(mock2, Is.Not.Null);
Assert.That(mock2, Is.InstanceOfType(typeof(GenericImpl<int>)));
}
}
public void ServiceBoundTypeReceivesPrivateFieldInjection()
{
var module = new InlineModule(m => m.Bind(typeof(IMock)).To(typeof(RequestsPrivateFieldInjection)));
var options = new KernelOptions { InjectNonPublicMembers = true };
using (var kernel = new StandardKernel(options, module))
{
var mock = kernel.Get<IMock>();
Assert.That(mock, Is.Not.Null);
var typedMock = mock as RequestsPrivateFieldInjection;
Assert.That(typedMock, Is.Not.Null);
Assert.That(typedMock.Child, Is.Not.Null);
}
}
public void OptionalDependenciesForServiceBoundTypesAreResolved()
{
IModule module = new InlineModule(m =>
{
m.Bind<IMock>().To<SimpleObject>();
});
using (var kernel = new StandardKernel(module))
{
RequestsOptionalService parent = kernel.Get<RequestsOptionalService>();
Assert.That(parent, Is.Not.Null);
Assert.That(parent.Child, Is.Not.Null);
Assert.That(parent.Child, Is.InstanceOfType(typeof(SimpleObject)));
}
}
public void CanBindType()
{
var module = new InlineModule(m => m.Bind<IMock>().To<SimpleObject>());
using (var kernel = new StandardKernel(module))
{
IContext context = kernel.Components.ContextFactory.Create(typeof(IMock));
IBinding binding = kernel.Components.BindingSelector.SelectBinding(typeof(IMock), context);
var provider = binding.Provider as StandardProvider;
Assert.That(binding, Is.Not.Null);
Assert.That(provider, Is.Not.Null);
Assert.That(provider.GetImplementationType(context), Is.EqualTo(typeof(SimpleObject)));
}
}
public void BindingParametersAllowHybridInjectionOfMissingConstructorArguments()
{
IModule module = new InlineModule(
m => m.Bind<IMock>().To<ImplA>(),
m => m.Bind<HybridInjectionMock>().ToSelf().WithConstructorArgument("connectionString", "this is a connection string")
);
using (var kernel = new StandardKernel(module))
{
var mock = kernel.Get<HybridInjectionMock>();
Assert.That(mock, Is.Not.Null);
Assert.That(mock.Child, Is.Not.Null);
Assert.That(mock.Child, Is.InstanceOfType(typeof(ImplA)));
Assert.That(mock.ConnectionString, Is.EqualTo("this is a connection string"));
}
}
public void HeuristicIgnoresMethodsIfItCannotInjectValuesForAllArguments()
{
var testModule = new InlineModule(
m => m.Bind<PocoForMethodAutoWiring>().ToSelf(),
m => m.Bind<IMock>().To<SimpleObject>()
);
using (var kernel = new StandardKernel(new AutoWiringModule(), testModule))
{
var mock = kernel.Get<PocoForMethodAutoWiring>();
Assert.That(mock, Is.Not.Null);
Assert.That(mock.Child, Is.Null);
Assert.That(mock.ServiceA, Is.Null);
Assert.That(mock.ServiceB, Is.Null);
}
}
public void BindingParameterCanOverrideInjectedValueForPropertyValue()
{
var child = new SimpleObject();
var module = new InlineModule(
m => m.Bind<RequestsPropertyInjection>().ToSelf().WithPropertyValue("Child", child)
);
using (var kernel = new StandardKernel(module))
{
var mock = kernel.Get<RequestsPropertyInjection>();
Assert.That(mock, Is.Not.Null);
Assert.That(mock.Child, Is.Not.Null);
Assert.That(mock.Child, Is.SameAs(child));
}
}
public void CanBindConstant()
{
var module = new InlineModule(m => m.Bind<string>().ToConstant("test"));
using (var kernel = new StandardKernel(module))
{
IContext context = kernel.Components.ContextFactory.Create(typeof(string));
IBinding binding = kernel.Components.BindingSelector.SelectBinding(typeof(string), context);
var provider = binding.Provider as ConstantProvider;
Assert.That(binding, Is.Not.Null);
Assert.That(provider, Is.Not.Null);
Assert.That(provider.GetImplementationType(context), Is.EqualTo(typeof(string)));
Assert.That(provider.Value, Is.EqualTo("test"));
}
}
public void ContextParameterOverridesBindingParameterForConstructorArgument()
{
var childInBinding = new SimpleObject();
var childInContext = new SimpleObject();
var module = new InlineModule(
m => m.Bind<RequestsConstructorInjection>().ToSelf().WithConstructorArgument("child", childInBinding)
);
using (var kernel = new StandardKernel(module))
{
var mock = kernel.Get<RequestsConstructorInjection>(With.Parameters.ConstructorArgument("child", childInContext));
Assert.That(mock, Is.Not.Null);
Assert.That(mock.Child, Is.Not.Null);
Assert.That(mock.Child, Is.SameAs(childInContext));
}
}
public void SelfBoundTypesDeclaringMethodInterceptorsAreIntercepted()
{
var testModule = new InlineModule(m => m.Bind<ObjectWithMethodInterceptor>().ToSelf());
using (var kernel = new StandardKernel(new LinFuModule(), testModule))
{
var obj = kernel.Get<ObjectWithMethodInterceptor>();
Assert.That(obj, Is.Not.Null);
Assert.That(obj, Is.InstanceOfType(typeof(IProxy)));
CountInterceptor.Reset();
obj.Foo();
obj.Bar();
Assert.That(CountInterceptor.Count, Is.EqualTo(1));
}
}
public void SelfBoundTypesDeclaringInterceptorsOnGenericMethodsAreIntercepted()
{
var testModule = new InlineModule(m => m.Bind<ObjectWithGenericMethod>().ToSelf());
using (var kernel = new StandardKernel(new LinFuModule(), testModule))
{
var obj = kernel.Get<ObjectWithGenericMethod>();
Assert.That(obj, Is.Not.Null);
Assert.That(obj, Is.InstanceOfType(typeof(IProxy)));
FlagInterceptor.Reset();
string result = obj.ConvertGeneric(42);
Assert.That(result, Is.EqualTo("42"));
Assert.That(FlagInterceptor.WasCalled, Is.True);
}
}
public void BindingHeuristicSelectsConstructorForInjection()
{
var module = new InlineModule(
m => m.Bind<IMock>().To<RequestsConstructorInjectionWithoutAttribute>()
.InjectConstructor(When.Constructor.Parameters.Count == 1)
);
using (var kernel = new StandardKernel(module))
{
var mock = kernel.Get<IMock>();
Assert.That(mock, Is.Not.Null);
var typedMock = mock as RequestsConstructorInjectionWithoutAttribute;
Assert.That(typedMock, Is.Not.Null);
Assert.That(typedMock.Child, Is.Not.Null);
Assert.That(typedMock.Child, Is.InstanceOfType(typeof(SimpleObject)));
}
}
public void ContextVariablesCanBeUsedToAlterBindingsWithCaseInsensitivity()
{
var module = new InlineModule(
m => m.Bind(typeof(IMock)).To(typeof(ImplA)).Only(When.Context.Variable("bind").EqualTo("Foo", StringComparer.OrdinalIgnoreCase)),
m => m.Bind(typeof(IMock)).To(typeof(ImplB)).Only(When.Context.Variable("bind").EqualTo("BaR", StringComparer.OrdinalIgnoreCase))
);
using (var kernel = new StandardKernel(module))
{
var mock1 = kernel.Get<IMock>(With.Parameters.Variable("bind", "FOO"));
Assert.That(mock1, Is.Not.Null);
Assert.That(mock1, Is.InstanceOfType(typeof(ImplA)));
var mock2 = kernel.Get<IMock>(With.Parameters.Variable("bind", "bar"));
Assert.That(mock2, Is.Not.Null);
Assert.That(mock2, Is.InstanceOfType(typeof(ImplB)));
}
}
public void HeuristicSelectsConstructorWithMostValidArgumentsEvenIfNotLargest()
{
var testModule = new InlineModule(
m => m.Bind<PocoForPropertyAutoWiring>().ToSelf(),
m => m.Bind<IMock>().To<SimpleObject>()
);
using (var kernel = new StandardKernel(new AutoWiringModule(), testModule))
{
var mock = kernel.Get<PocoForPropertyAutoWiring>();
Assert.That(mock, Is.Not.Null);
Assert.That(mock.Child, Is.Not.Null);
Assert.That(mock.Child, Is.InstanceOfType(typeof(SimpleObject)));
Assert.That(mock.ServiceA, Is.Null);
Assert.That(mock.ServiceB, Is.Null);
}
}
public void MemberBasedBindingOfConstantDependencies()
{
IModule module = new InlineModule(
m => m.Bind<string>().ToConstant("Hello, world!").Only(When.Context.Member.Tag.EqualTo("HelloWorld")),
m => m.Bind<string>().ToConstant("SNAFU").Only(When.Context.Member.Tag.EqualTo("FooBar"))
);
using (var kernel = new StandardKernel(module))
{
var obj1 = kernel.Get<RequestsHelloWorldConstant>();
Assert.That(obj1, Is.Not.Null);
Assert.That(obj1.Message, Is.Not.Null);
Assert.That(obj1.Message, Is.EqualTo("Hello, world!"));
var obj2 = kernel.Get<RequestsFooBarConstant>();
Assert.That(obj2, Is.Not.Null);
Assert.That(obj2.Message, Is.Not.Null);
Assert.That(obj2.Message, Is.EqualTo("SNAFU"));
}
}
