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