public void HeuristicSelectsPropertiesIfTheyHaveMatchingBindings()
{
var testModule = new InlineModule(
m => m.Bind <PocoForFieldAutoWiring>().ToSelf(),
m => m.Bind <IServiceA>().To <ServiceImplA>(),
m => m.Bind <IServiceB>().To <ServiceImplB>()
);
var options = new KernelOptions {
InjectNonPublicMembers = true
};
using (var kernel = new StandardKernel(options, new AutoWiringModule(), testModule))
{
var mock = kernel.Get <PocoForFieldAutoWiring>();
Assert.That(mock, Is.Not.Null);
Assert.That(mock.Child, Is.Null);
Assert.That(mock.ServiceA, Is.Not.Null);
Assert.That(mock.ServiceA, Is.InstanceOfType(typeof(ServiceImplA)));
Assert.That(mock.ServiceB, Is.Not.Null);
Assert.That(mock.ServiceB, Is.InstanceOfType(typeof(ServiceImplB)));
}
}
public void IncompatibleProviderAndBindingServiceTypeThrowsException()
{
var module = new InlineModule(m => m.Bind(typeof(IMock)).To(typeof(ObjectWithNoInterfaces)));
var options = new KernelOptions {
IgnoreProviderCompatibility = false
};
using (var kernel = new StandardKernel(options, module))
{
kernel.Get <IMock>();
}
}
public void IncompatibleProviderAllowedIfProviderCompatibilityIsIgnored()
{
var module = new InlineModule(m => m.Bind(typeof(IMock)).To(typeof(ObjectWithNoInterfaces)));
var options = new KernelOptions {
IgnoreProviderCompatibility = true
};
using (var kernel = new StandardKernel(options, module))
{
var mock = kernel.Get(typeof(IMock)) as ObjectWithNoInterfaces;
Assert.That(mock, Is.Not.Null);
}
}
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 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 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 CanInjectCircularReferencesIntoMethods()
{
var module = new InlineModule(
m => m.Bind <CircularMethodMockA>().ToSelf(),
m => m.Bind <CircularMethodMockB>().ToSelf()
);
var options = new KernelOptions {
InjectNonPublicMembers = true
};
using (var kernel = new StandardKernel(options, module))
{
var mockA = kernel.Get <CircularMethodMockA>();
var mockB = kernel.Get <CircularMethodMockB>();
Assert.That(mockA, Is.Not.Null);
Assert.That(mockB, Is.Not.Null);
Assert.That(mockA.MockB, Is.SameAs(mockB));
Assert.That(mockB.MockA, Is.SameAs(mockA));
}
}
public void EagerActivationCausesSingletonInstancesToBeImmediatelyActivated()
{
var module = new InlineModule(m => m.Bind <ObjectWithSingletonBehavior>().ToSelf());
var options = new KernelOptions {
UseEagerActivation = true
};
using (var kernel = new StandardKernel(options, module))
{
Type type = typeof(ObjectWithSingletonBehavior);
IContext context = kernel.Components.ContextFactory.Create(type);
IBinding binding = kernel.Components.BindingSelector.SelectBinding(type, context);
Assert.That(binding, Is.Not.Null);
IActivationPlan plan = binding.Components.Planner.GetPlan(binding, type);
var behavior = plan.Behavior as SingletonBehavior;
Assert.That(behavior, Is.Not.Null);
Assert.That(behavior.ContextCache, Is.Not.Empty);
}
}
public void HeuristicSelectsConstructorWithMostValidArgumentsEvenIfNotLargest()
{
var testModule = new InlineModule(
m => m.Bind <PocoForFieldAutoWiring>().ToSelf(),
m => m.Bind <IMock>().To <SimpleObject>()
);
var options = new KernelOptions {
InjectNonPublicMembers = true
};
using (var kernel = new StandardKernel(options, new AutoWiringModule(), testModule))
{
var mock = kernel.Get <PocoForFieldAutoWiring>();
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);
}
}
