protected void Application_Start(object sender, EventArgs e) {
var kernel = new DefaultKernel();
kernel.Register(Component.For<HttpContextBase>()
.LifeStyle.Transient
.UsingFactoryMethod(() => new HttpContextWrapper(HttpContext.Current)));
kernel.Register(Component.For<SomeService>()
.LifeStyle.HybridPerWebRequestTransient());
kernel.Resolve<SomeService>();
}
public static ICollection<IHandler> SimulateRegistration(this IRegistration reg)
{
using (var kernel = new DefaultKernel()) {
kernel.Register(reg);
return kernel.GetAssignableHandlers(typeof (object));
}
}
public void TestComponentWithNoInterface()
{
IKernel kernel = new DefaultKernel();
kernel.ComponentCreated += new ComponentInstanceDelegate(OnNoInterfaceStartableComponentStarted);
MutableConfiguration compNode = new MutableConfiguration("component");
compNode.Attributes["id"] = "b";
compNode.Attributes["startable"] = "true";
compNode.Attributes["startMethod"] = "Start";
compNode.Attributes["stopMethod"] = "Stop";
kernel.ConfigurationStore.AddComponentConfiguration("b", compNode);
kernel.AddFacility("startable", new StartableFacility());
kernel.Register(Component.For(typeof(NoInterfaceStartableComponent)).Named("b"));
Assert.IsTrue(startableCreatedBeforeResolved, "Component was not properly started");
NoInterfaceStartableComponent component = kernel["b"] as NoInterfaceStartableComponent;
Assert.IsNotNull(component);
Assert.IsTrue(component.Started);
Assert.IsFalse(component.Stopped);
kernel.ReleaseComponent(component);
Assert.IsTrue(component.Stopped);
}
public void Starts_component_without_start_method()
{
ClassWithInstanceCount.InstancesCount = 0;
IKernel kernel = new DefaultKernel();
kernel.AddFacility<StartableFacility>(f => f.DeferredTryStart());
kernel.Register(Component.For<ClassWithInstanceCount>().Start());
Assert.AreEqual(1, ClassWithInstanceCount.InstancesCount);
}
public void tt()
{
var kernel = new DefaultKernel();
kernel.Register(AllTypes.Pick()
.FromAssembly(Assembly.GetExecutingAssembly())
.WithService.FirstInterface());
kernel.Resolve<ISomeInterface>();
}
public void get_services_returns_registered_service()
{
var kernel = new DefaultKernel();
kernel.Register(Component.For<object>().Instance(new object()));
var resolver = new CastleDependencyResolver(kernel);
var services = resolver.GetServices(typeof(object));
Assert.That(services.Count(), Is.EqualTo(1));
}
public void DoesNotResolveArraysByDefault()
{
var kernel = new DefaultKernel();
kernel.Register(
Component.For<Thing>(),
Component.For<ISubThing>().ImplementedBy<First>(),
Component.For<ISubThing>().ImplementedBy<Second>(),
Component.For<ISubThing>().ImplementedBy<Third>()
);
var thing = kernel.Resolve<Thing>();
}
public void DoesNotDiscoverCircularDependencies()
{
var kernel = new DefaultKernel();
kernel.Resolver.AddSubResolver(new ArrayResolver(kernel));
// a circular reference exception should be thrown here
kernel.Register(
Component.For<Thing>(),
Component.For<ISubThing>().ImplementedBy<Circular>()
);
// this crashes the test framework!
// var thing = kernel.Resolve<Thing>();
}
public void SetUp()
{
kernel = new DefaultKernel();
kernel.AddFacility<StartableFacility>();
kernel.Register(
Component.For<StartableDisposableAndInitializableComponent>()
.LifeStyle.Transient
);
component = kernel.Resolve<StartableDisposableAndInitializableComponent>();
component.DoSomething();
kernel.ReleaseComponent(component);
calledMethods = component.calledMethods;
}
public void LeaseIsCorrectWhenAccessedAfterInitializationWhenLeaseIsAvailabeInKernel()
{
// Fixture setup
var kernel = new DefaultKernel();
var model = new ComponentModel("foo", typeof(ICloneable), typeof(Version));
var activator = kernel.CreateComponentActivator(model);
var expectedLease = new Mock<ILease> { DefaultValue = DefaultValue.Mock }.Object;
kernel.Register(Component.For<ILease>().Instance(expectedLease));
var sut = new CacheLifestyleManager();
sut.Init(activator, kernel, model);
// Exercise system
var result = sut.Lease;
// Verify outcome
Assert.Equal(expectedLease, result);
// Teardown
}
public void ShouldResolveArrayOfDependencies()
{
var kernel = new DefaultKernel();
kernel.Resolver.AddSubResolver(new ArrayResolver(kernel));
kernel.Register(
Component.For<Thing>(),
Component.For<ISubThing>().ImplementedBy<First>(),
Component.For<ISubThing>().ImplementedBy<Second>(),
Component.For<ISubThing>().ImplementedBy<Third>()
);
var thing = kernel.Resolve<Thing>();
Assert.That(thing.SubThings.Count, Is.EqualTo(3));
Assert.That(thing.SubThings[0], Is.InstanceOf(typeof(First)));
Assert.That(thing.SubThings[1], Is.InstanceOf(typeof(Second)));
Assert.That(thing.SubThings[2], Is.InstanceOf(typeof(Third)));
}
public void TestInterfaceBasedStartable()
{
IKernel kernel = new DefaultKernel();
kernel.ComponentCreated += new ComponentInstanceDelegate(OnStartableComponentStarted);
kernel.AddFacility("startable", new StartableFacility());
kernel.Register(Component.For(typeof(StartableComponent)).Named("a"));
Assert.IsTrue(startableCreatedBeforeResolved, "Component was not properly started");
StartableComponent component = kernel["a"] as StartableComponent;
Assert.IsNotNull(component);
Assert.IsTrue(component.Started);
Assert.IsFalse(component.Stopped);
kernel.ReleaseComponent(component);
Assert.IsTrue(component.Stopped);
}
public void Parent_component_will_NOT_have_dependencies_from_child()
{
Kernel.Register(Component.For<DefaultTemplateEngine>(),
Component.For<DefaultSpamService>());
var child = new DefaultKernel();
Kernel.AddChildKernel(child);
child.Register(Component.For<DefaultMailSenderService>());
var spamservice = child.Resolve<DefaultSpamService>();
Assert.IsNotNull(spamservice);
Assert.IsNotNull(spamservice.TemplateEngine);
Assert.IsNull(spamservice.MailSender);
}
public void Requesting_parent_component_with_child_dependency_from_child_component()
{
var subkernel = new DefaultKernel();
Kernel.AddChildKernel(subkernel);
Kernel.Register(Component.For<UsesSimpleComponent1>());
subkernel.Register(Component.For<SimpleComponent1>());
subkernel.Resolve<UsesSimpleComponent1>();
}
public void ParentKernelFindsAndCreateChildComponent()
{
IKernel subkernel = new DefaultKernel();
subkernel.Register(Component.For(typeof(DefaultTemplateEngine)).Named("templateengine"));
Kernel.AddChildKernel(subkernel);
Assert.IsFalse(Kernel.HasComponent(typeof(DefaultTemplateEngine)));
Kernel.Resolve<DefaultTemplateEngine>();
}
public void DependenciesSatisfiedAmongContainersUsingEvents()
{
IKernel subkernel = new DefaultKernel();
subkernel.Register(Component.For(typeof(DefaultSpamServiceWithConstructor)).Named("spamservice"));
Kernel.Register(Component.For(typeof(DefaultMailSenderService)).Named("mailsender"));
Kernel.Register(Component.For(typeof(DefaultTemplateEngine)).Named("templateengine"));
Kernel.AddChildKernel(subkernel);
var spamservice =
subkernel.Resolve<DefaultSpamServiceWithConstructor>("spamservice");
Assert.IsNotNull(spamservice);
Assert.IsNotNull(spamservice.MailSender);
Assert.IsNotNull(spamservice.TemplateEngine);
}
public void TestStartableComponentWithServiceDependency()
{
IKernel kernel = new DefaultKernel();
kernel.ComponentModelBuilder.AddContributor(new ServiceDependencyComponentInspector());
kernel.ComponentCreated += new ComponentInstanceDelegate(OnStartableComponentWithServiceDependencyStarted);
kernel.AddFacility("startable", new StartableFacility());
kernel.Register(Component.For<StartableComponentWithServiceDependency>());
Assert.IsFalse(startableCreatedBeforeResolved, "Component was started before dependency was registered");
kernel.Register(Component.For<ServiceDependency>());
Assert.IsTrue(startableCreatedBeforeResolved, "Component was not properly started");
StartableComponentWithServiceDependency component = kernel.Resolve<StartableComponentWithServiceDependency>();
Assert.IsNotNull(component);
Assert.IsTrue(component.Started);
Assert.IsFalse(component.Stopped);
kernel.ReleaseComponent(component);
Assert.IsTrue(component.Stopped);
}
public void ChildDependenciesIsSatisfiedEvenWhenComponentTakesLongToBeAddedToParentContainer()
{
var container = new DefaultKernel();
var childContainer = new DefaultKernel();
container.AddChildKernel(childContainer);
childContainer.Register(Component.For(typeof(UsesIEmptyService)).Named("component"));
container.Register(
Component.For(typeof(IEmptyService)).ImplementedBy(typeof(EmptyServiceA)).Named("service1"));
childContainer.Resolve<UsesIEmptyService>();
}
public void TestStartableWithRegisteredCustomDependencies()
{
IKernel kernel = new DefaultKernel();
kernel.ComponentCreated += new ComponentInstanceDelegate(OnStartableComponentStarted);
kernel.AddFacility("startable", new StartableFacility());
var dependencies = new Dictionary<string, object> { { "config", 1 } };
kernel.Register(Component.For(typeof(StartableComponentCustomDependencies)).Named("a"));
kernel.RegisterCustomDependencies(typeof(StartableComponentCustomDependencies), dependencies);
Assert.IsTrue(startableCreatedBeforeResolved, "Component was not properly started");
StartableComponentCustomDependencies component = kernel["a"] as StartableComponentCustomDependencies;
Assert.IsNotNull(component);
Assert.IsTrue(component.Started);
Assert.IsFalse(component.Stopped);
kernel.ReleaseComponent(component);
Assert.IsTrue(component.Stopped);
}
public void ReleaseWrongObjectWillNotReleaseInstance()
{
// Fixture setup
var kernel = new DefaultKernel();
var model = new ComponentModel("foo", typeof(ICloneable), typeof(Version));
var activator = kernel.CreateComponentActivator(model);
var leaseMock = new Mock<ILease> { DefaultValue = DefaultValue.Mock };
kernel.Register(Component.For<ILease>().Instance(leaseMock.Object));
var sut = new CacheLifestyleManager();
sut.Init(activator, kernel, model);
var first = sut.Resolve(CreationContext.Empty);
// Exercise system
sut.Release(new object());
// Verify outcome
var second = sut.Resolve(CreationContext.Empty);
Assert.Same(first, second);
// Teardown
}
public void TestStartableChainWithGenerics()
{
IKernel kernel = new DefaultKernel();
kernel.AddFacility("startable", new StartableFacility());
// Add parent. This has a dependency so won't be started yet.
kernel.Register(Component.For(typeof(StartableChainParent)).Named("chainparent"));
Assert.AreEqual(0, StartableChainDependency.startcount);
Assert.AreEqual(0, StartableChainDependency.createcount);
// Add generic dependency. This is not startable so won't get created.
kernel.Register(Component.For(typeof(StartableChainGeneric<>)).Named("chaingeneric"));
Assert.AreEqual(0, StartableChainDependency.startcount);
Assert.AreEqual(0, StartableChainDependency.createcount);
// Add dependency. This will satisfy the dependency so everything will start.
kernel.Register(Component.For(typeof(StartableChainDependency)).Named("chaindependency"));
Assert.AreEqual(1, StartableChainParent.startcount);
Assert.AreEqual(1, StartableChainParent.createcount);
Assert.AreEqual(1, StartableChainDependency.startcount);
Assert.AreEqual(1, StartableChainDependency.createcount);
Assert.AreEqual(1, StartableChainGeneric<string>.createcount);
}
public void TestStartableCustomDependencies()
{
IKernel kernel = new DefaultKernel();
kernel.ComponentCreated += new ComponentInstanceDelegate(OnStartableComponentStarted);
kernel.AddFacility("startable", new StartableFacility());
kernel.Register(
Component.For<StartableComponentCustomDependencies>()
.Named("a")
.DependsOn(Property.ForKey("config").Eq(1))
);
Assert.IsTrue(startableCreatedBeforeResolved, "Component was not properly started");
StartableComponentCustomDependencies component = kernel["a"] as StartableComponentCustomDependencies;
Assert.IsNotNull(component);
Assert.IsTrue(component.Started);
Assert.IsFalse(component.Stopped);
kernel.ReleaseComponent(component);
Assert.IsTrue(component.Stopped);
}
public void Singleton_withNonSingletonDependencies_doesNotReResolveDependencies()
{
Kernel.Register(Component.For(typeof(DefaultSpamService)).Named("spamservice"));
Kernel.Register(Component.For(typeof(DefaultMailSenderService)).Named("mailsender"));
var subkernel1 = new DefaultKernel();
subkernel1.Register(Component.For(typeof(DefaultTemplateEngine)).Named("templateengine"));
Kernel.AddChildKernel(subkernel1);
var subkernel2 = new DefaultKernel();
subkernel2.Register(Component.For(typeof(DefaultTemplateEngine)).Named("templateengine")
.LifeStyle.Is(LifestyleType.Transient));
Kernel.AddChildKernel(subkernel2);
var templateengine1 = subkernel1.Resolve<DefaultTemplateEngine>("templateengine");
var spamservice1 = subkernel1.Resolve<DefaultSpamService>("spamservice");
Assert.IsNull(spamservice1.TemplateEngine);
var templateengine2 = subkernel2.Resolve<DefaultTemplateEngine>("templateengine");
var spamservice2 = subkernel2.Resolve<DefaultSpamService>("spamservice");
Assert.AreSame(spamservice1, spamservice2);
}
public void ResolveWillReturnNewInstanceWhenLeaseExpires()
{
// Fixture setup
var kernel = new DefaultKernel();
var model = new ComponentModel("foo", typeof(ICloneable), typeof(Version));
var activator = kernel.CreateComponentActivator(model);
var expired = false;
var leaseStub = new Mock<ILease> { DefaultValue = DefaultValue.Mock };
leaseStub.Setup(l => l.IsExpired).Returns(() =>
{
var b = expired;
expired = !expired;
return b;
});
kernel.Register(Component.For<ILease>().Instance(leaseStub.Object));
var sut = new CacheLifestyleManager();
sut.Init(activator, kernel, model);
// Exercise system
var first = sut.Resolve(CreationContext.Empty);
var second = sut.Resolve(CreationContext.Empty);
// Verify outcome
Assert.NotSame(first, second);
// Teardown
}
public void Do_NOT_UseChildComponentsForParentDependenciesWhenRequestedFromChild()
{
IKernel subkernel = new DefaultKernel();
Kernel.Register(Component.For(typeof(DefaultSpamService)).Named("spamservice").LifeStyle.Is(LifestyleType.Transient));
Kernel.Register(Component.For(typeof(DefaultMailSenderService)).Named("mailsender"));
Kernel.Register(Component.For(typeof(DefaultTemplateEngine)).Named("templateengine"));
Kernel.AddChildKernel(subkernel);
subkernel.Register(Component.For(typeof(DefaultTemplateEngine)).Named("templateengine"));
var templateengine = Kernel.Resolve<DefaultTemplateEngine>("templateengine");
var sub_templateengine = subkernel.Resolve<DefaultTemplateEngine>("templateengine");
var spamservice = subkernel.Resolve<DefaultSpamService>("spamservice");
Assert.AreNotEqual(spamservice.TemplateEngine, sub_templateengine);
Assert.AreEqual(spamservice.TemplateEngine, templateengine);
spamservice = Kernel.Resolve<DefaultSpamService>("spamservice");
Assert.AreNotEqual(spamservice.TemplateEngine, sub_templateengine);
Assert.AreEqual(spamservice.TemplateEngine, templateengine);
}
public void ChildKernelOverloadsParentKernel1()
{
var instance1 = new DefaultTemplateEngine();
var instance2 = new DefaultTemplateEngine();
// subkernel added with already registered components that overload parent components.
IKernel subkernel = new DefaultKernel();
subkernel.Register(Component.For<DefaultTemplateEngine>().Named("engine").Instance(instance1));
Assert.AreEqual(instance1, subkernel.Resolve<DefaultTemplateEngine>("engine"));
Kernel.Register(Component.For<DefaultTemplateEngine>().Named("engine").Instance(instance2));
Assert.AreEqual(instance2, Kernel.Resolve<DefaultTemplateEngine>("engine"));
Kernel.AddChildKernel(subkernel);
Assert.AreEqual(instance1, subkernel.Resolve<DefaultTemplateEngine>("engine"));
Assert.AreEqual(instance2, Kernel.Resolve<DefaultTemplateEngine>("engine"));
}
public void MultipleResolvesWillOnlyRenewOnce()
{
// Fixture setup
var kernel = new DefaultKernel();
var model = new ComponentModel("foo", typeof(ICloneable), typeof(Version));
var activator = kernel.CreateComponentActivator(model);
var leaseMock = new Mock<ILease> { DefaultValue = DefaultValue.Mock };
kernel.Register(Component.For<ILease>().Instance(leaseMock.Object));
var sut = new CacheLifestyleManager();
sut.Init(activator, kernel, model);
// Exercise system
sut.Resolve(CreationContext.Empty);
sut.Resolve(CreationContext.Empty);
// Verify outcome
leaseMock.Verify(l => l.Renew(), Times.Once());
// Teardown
}
public void ChildKernelOverloadsParentKernel2()
{
var instance1 = new DefaultTemplateEngine();
var instance2 = new DefaultTemplateEngine();
IKernel subkernel = new DefaultKernel();
Kernel.AddChildKernel(subkernel);
// subkernel added first, then populated with overloaded components after
Kernel.Register(Component.For<DefaultTemplateEngine>().Named("engine").Instance(instance2));
Assert.AreEqual(instance2, Kernel.Resolve<DefaultTemplateEngine>("engine"));
Assert.AreEqual(instance2, subkernel.Resolve<DefaultTemplateEngine>("engine"));
subkernel.Register(Component.For<DefaultTemplateEngine>().Named("engine").Instance(instance1));
Assert.AreEqual(instance1, subkernel.Resolve<DefaultTemplateEngine>("engine"));
Assert.AreEqual(instance2, Kernel.Resolve<DefaultTemplateEngine>("engine"));
}
public void Test_KernelRegister2()
{
var context = new ConventionalRegistrationContext(
Assembly.GetExecutingAssembly(),
LocalIocManager,
new ConventionalRegistrationConfig());
var result = BasedOnDescriptor(context);
var kernel = new DefaultKernel();
kernel.Register(result);
}
public void SameLevelDependenciesSatisfied()
{
IKernel child = new DefaultKernel();
Kernel.Register(Component.For(typeof(DefaultTemplateEngine)).Named("templateengine"));
Kernel.Register(Component.For(typeof(DefaultSpamService)).Named("spamservice"));
Kernel.AddChildKernel(child);
child.Register(Component.For(typeof(DefaultMailSenderService)).Named("mailsender"));
var spamservice = child.Resolve<DefaultSpamService>("spamservice");
Assert.IsNotNull(spamservice);
Assert.IsNotNull(spamservice.MailSender);
Assert.IsNotNull(spamservice.TemplateEngine);
}
