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(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 TryingToUnloadAModuleThatIsNotLoadedThrowsException()
{
var moduleA = new MockModuleA();
using (var kernel = new StandardKernel())
kernel.Unload(moduleA);
}
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 ManyPublishersOneSubscriber()
{
using (var kernel = new StandardKernel(new MessageBrokerModule()))
{
PublisherMock pub1 = kernel.Get<PublisherMock>();
PublisherMock pub2 = kernel.Get<PublisherMock>();
Assert.That(pub1, Is.Not.Null);
Assert.That(pub2, Is.Not.Null);
SubscriberMock sub = kernel.Get<SubscriberMock>();
Assert.That(sub, Is.Not.Null);
Assert.That(pub1.HasListeners);
Assert.That(pub2.HasListeners);
Assert.That(sub.LastMessage, Is.Null);
pub1.SendMessage("Hello, world!");
Assert.That(sub.LastMessage, Is.EqualTo("Hello, world!"));
sub.LastMessage = null;
Assert.That(sub.LastMessage, Is.Null);
pub2.SendMessage("Hello, world!");
Assert.That(sub.LastMessage, Is.EqualTo("Hello, world!"));
}
}
public void StandardKernelUsesDefaultOptions()
{
using (var kernel = new StandardKernel())
{
Assert.That(kernel.Options, Is.SameAs(KernelOptions.Default));
}
}
public void CanCallParameterlessConstructor()
{
using (var kernel = new StandardKernel())
{
var mock = kernel.Get<SimpleObject>();
Assert.That(mock, Is.Not.Null);
}
}
public void StartableObjectIsStartedWhenActivated()
{
using (var kernel = new StandardKernel())
{
var mock = kernel.Get<StartableMock>();
Assert.That(mock, Is.Not.Null);
Assert.That(mock.Started, Is.True);
}
}
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 static void Main()
{
IKernel kernel = new StandardKernel(new InlineModule(
m => m.Bind<IReportBuilder>().To<ReportBuilder>(),
m => m.Bind<IReportSender>().To<EmailReportSender>(),
m => m.Bind<IReporter>().To<Reporter>()
));
kernel.Get<IReporter>().SendReports();
}
public void SelfBoundTypeReceivesMethodInjection()
{
using (var kernel = new StandardKernel())
{
var mock = kernel.Get<RequestsMethodInjection>();
Assert.That(mock, Is.Not.Null);
Assert.That(mock.Child, Is.Not.Null);
}
}
/*----------------------------------------------------------------------------------------*/
private static IKernel CreateKernel()
{
IKernel kernel = new StandardKernel();
// The test will not pass with just the StandardKernel, because the NullLoggerFactory
// returns the same instance of NullLogger to use as a flyweight.
kernel.Components.Connect<ILoggerFactory>(new ConsoleLoggerFactory());
return kernel;
}
public void OptionalDependenciesForServiceBoundTypesAreIgnoredIfNoBindingsExist()
{
using (var kernel = new StandardKernel())
{
RequestsOptionalService parent = kernel.Get<RequestsOptionalService>();
Assert.That(parent, Is.Not.Null);
Assert.That(parent.Child, Is.Null);
}
}
public void ConstructorReceivesInjection()
{
using (var kernel = new StandardKernel())
{
var mock = kernel.Get<RequestsConstructorInjection>();
Assert.That(mock, Is.Not.Null);
Assert.That(mock.Child, Is.Not.Null);
Assert.That(mock.Child, Is.InstanceOfType(typeof(SimpleObject)));
}
}
public void CanInjectKernelInstanceIntoConstructors()
{
using (var kernel = new StandardKernel())
{
var mock = kernel.Get<RequestsKernelViaConstructorInjection>();
Assert.That(mock, Is.Not.Null);
Assert.That(mock.Kernel, Is.Not.Null);
Assert.That(mock.Kernel, Is.SameAs(kernel));
}
}
public void ExistingInstanceReceivesFieldInjection()
{
using (var kernel = new StandardKernel())
{
RequestsFieldInjection mock = new RequestsFieldInjection();
kernel.Inject(mock);
Assert.That(mock.Child, Is.Not.Null);
Assert.That(mock.Child, Is.InstanceOfType(typeof(SimpleObject)));
}
}
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)));
}
}
protected override IKernel CreateKernel()
{
IModule[] modules = new IModule[]
{
new AutoControllerModule(
Assembly.GetExecutingAssembly()),
new InMemoryModule()
};
_kernel = new StandardKernel(modules);
return _kernel;
}
public void DisposableObjectIsDisposedWhenReleased()
{
using (var kernel = new StandardKernel())
{
var mock = kernel.Get<DisposableMock>();
Assert.That(mock, Is.Not.Null);
kernel.Release(mock);
Assert.That(mock.Disposed, Is.True);
}
}
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 OptionalDependenciesForSelfBoundTypesAreResolved()
{
using (var kernel = new StandardKernel())
{
RequestsOptionalConcreteType parent = kernel.Get<RequestsOptionalConcreteType>();
Assert.That(parent, Is.Not.Null);
Assert.That(parent.Child, Is.Not.Null);
Assert.That(parent.Child, Is.InstanceOfType(typeof(SimpleObject)));
}
}
protected override IKernel CreateKernel()
{
IKernel kernel = new StandardKernel();
INinjectModuleAutoLoader moduleAutoLoader = new NinjectModuleAutoLoader(kernel);
moduleAutoLoader.InitAndLoadModulesForLoadedAssemblies();
KernelLocator.Kernel = kernel;
return kernel;
}
public void ManyInstancesCreatedForTransientTypes()
{
using (var kernel = new StandardKernel())
{
ObjectWithTransientBehavior mock1 = kernel.Get<ObjectWithTransientBehavior>();
ObjectWithTransientBehavior mock2 = kernel.Get<ObjectWithTransientBehavior>();
Assert.That(mock1, Is.Not.Null);
Assert.That(mock2, Is.Not.Null);
Assert.That(mock1, Is.Not.SameAs(mock2));
}
}
public void StartableObjectIsStoppedWhenReleased()
{
using (var kernel = new StandardKernel())
{
var mock = kernel.Get<StartableMock>();
Assert.That(mock, Is.Not.Null);
Assert.That(mock.Started, Is.True);
kernel.Release(mock);
Assert.That(mock.Started, Is.False);
}
}
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 SelfBoundTypeReceivesPrivateMethodInjection()
{
var options = new KernelOptions { InjectNonPublicMembers = true };
using (var kernel = new StandardKernel(options))
{
var mock = kernel.Get<RequestsPrivateMethodInjection>();
Assert.That(mock, Is.Not.Null);
Assert.That(mock.Child, Is.Not.Null);
}
}
public void BehaviorDefaultsToTransient()
{
using (var kernel = new StandardKernel())
{
SimpleObject mock1 = kernel.Get<SimpleObject>();
SimpleObject mock2 = kernel.Get<SimpleObject>();
Assert.That(mock1, Is.Not.Null);
Assert.That(mock2, Is.Not.Null);
Assert.That(mock1, Is.Not.SameAs(mock2));
}
}
public void SameInstanceReusedOnSameThreadForOnePerThreadTypes()
{
using (var kernel = new StandardKernel())
{
ObjectWithOnePerThreadBehavior mock1 = kernel.Get<ObjectWithOnePerThreadBehavior>();
ObjectWithOnePerThreadBehavior mock2 = kernel.Get<ObjectWithOnePerThreadBehavior>();
Assert.That(mock1, Is.Not.Null);
Assert.That(mock2, Is.Not.Null);
Assert.That(mock1, Is.SameAs(mock2));
}
}
public void CustomBehaviorProviderUsed()
{
using (var kernel = new StandardKernel())
{
ObjectWithCustomBehavior mock1 = kernel.Get<ObjectWithCustomBehavior>();
ObjectWithCustomBehavior mock2 = kernel.Get<ObjectWithCustomBehavior>();
Assert.That(mock1, Is.Not.Null);
Assert.That(mock2, Is.Not.Null);
Assert.That(mock1, Is.SameAs(mock2));
}
}
