public void CompileWorksWhenCompiledMultipleTimes() { using (var container = new IocContainer()) { // Arrange var foo = new Foo1(); var bar = new Bar1(); container.RegisterInstance <IFoo>(foo); container.RegisterInstance <IBar>(bar); container.Register <IFooBar, FooBar>().WithContainerLifetime(); container.Register <IFooBarContainer, FooBarContainer>().WithContainerLifetime(); // Act container.Compile(); container.Compile(); var fooBarContainer = container.Resolve <IFooBarContainer>(); // Assert Assert.IsNotNull(fooBarContainer); Assert.IsNotNull(fooBarContainer.FooBar); Assert.IsNotNull(fooBarContainer.FooBar.Foo); Assert.IsNotNull(fooBarContainer.FooBar.Bar); Assert.AreEqual(foo, fooBarContainer.FooBar.Foo); Assert.AreEqual(bar, fooBarContainer.FooBar.Bar); } }
public void CompileWorksWithPropertyInjection() { using (var container = new IocContainer()) { // Arrange container.Register <IFoo>(c => new Foo1()); container.Register <IBar>(c => new Bar1()); container.Register <IFooBar>(c => new FooBar() { Foo = c.Resolve <IFoo>(), Bar = c.Resolve <IBar>() }); // Act container.Compile(); var foo = container.Resolve <IFoo>(); var bar = container.Resolve <IBar>(); var foobar = container.Resolve <IFooBar>(); // Assert Assert.IsNotNull(foo); Assert.IsNotNull(bar); Assert.IsNotNull(foobar); Assert.IsNotNull(foobar.Foo); Assert.IsNotNull(foobar.Bar); } }
public void RequestLifetimeNestedWorksWithCompile() { // This doesnt work - will affect other Lifetimes that just nests the expression // Need to fix the scope of the input parameter IResolver using (var container = new IocContainer()) { // Arrange var context = new FakeHttpContext("Http://fakeUrl1.com"); var requestLifetime = new RequestLifetime(() => context, disposeOnEnd: false); // Do not test disposeOnEnd here container.Register <IFoo, Foo1>(); container.Register <IBar, Bar1>().SetLifetime(requestLifetime); container.Register <IFooBar, FooBar>(); container.Register <IFooBarContainer, FooBarContainer>(); // Act container.Compile(); var fooBarContainer = container.Resolve <IFooBarContainer>(); // Assert Assert.IsNotNull(fooBarContainer); Assert.IsNotNull(fooBarContainer.FooBar); Assert.IsNotNull(fooBarContainer.FooBar.Foo); Assert.IsNotNull(fooBarContainer.FooBar.Bar); } }
public void CompileDoesntBreakAnything() { using (var container = new IocContainer()) { // Arrange container.Register <IFoo>(c => new Foo1()); container.Register <IBar>(x => new Bar1(), "BarKey"); container.Register <IFooBar>(y => new FooBar((IFoo)y.Resolve(typeof(IFoo)), (IBar)y.Resolve(typeof(IBar), "BarKey"))); container.Register <IFooBar>(xyz => new FooBar(xyz.Resolve <IFoo>(), xyz.Resolve <IBar>("BarKey")), "FooBarKey"); // Act container.Compile(); var foo = container.Resolve <IFoo>(); var bar = container.Resolve <IBar>("BarKey"); var foobar1 = container.Resolve <IFooBar>(); var foobar2 = container.Resolve <IFooBar>("FooBarKey"); // Assert Assert.IsNotNull(foo); Assert.IsNotNull(bar); Assert.IsNotNull(foobar1); Assert.IsNotNull(foobar2); Assert.IsNotNull(foobar1.Foo, null); Assert.IsNotNull(foobar1.Bar, null); Assert.IsNotNull(foobar2.Foo, null); Assert.IsNotNull(foobar2.Bar, null); } }
void PrepareBasic() { IocContainer.ResetContainer(); RegisterDummies(); RegisterStandard(); RegisterComplexObject(); IocContainer.Compile(); }
void Prepare() { IocContainer.ResetContainer(); PrepareBasic(); RegisterPropertyInjection(); RegisterOpenGeneric(); RegisterMultiple(); RegisterConditional(); IocContainer.Compile(); }
public void CompileProtectsAgainstInfiniteLoop() { using (var container = new IocContainer()) { // Arrange container.Register <IFoo>(c => new Foo1()); container.Register <IBar>(x => new Bar2(x.Resolve <IFooBar>())); container.Register <IFooBar>(x => new FooBar(x.Resolve <IFoo>(), x.Resolve <IBar>())); // Act container.Compile(); } }
public void CompileThrowsExceptionIfRegistrationsAreNotValid() { using (var container = new IocContainer()) { // Arrange container.Register <IFoo>(c => new Foo1()); container.Register <IBar>(x => new Bar1(), "Bar"); container.Register <IFooBar>(x => new FooBar((IFoo)x.Resolve(typeof(IFoo)), (IBar)x.Resolve(typeof(IBar), "Bar"))); container.Register <IFooBar>(x => new FooBar(x.Resolve <IFoo>(), x.Resolve <IBar>()), "FooBar"); // Act container.Compile(); } }
public void CompileDoesntBreakAnything() { // What to do with this ... ? // To find out if anything was actually compiled it needs to inspect the Expression/Lambda created using (var container = new IocContainer()) { // Arrange container.Register<IFoo>(c => new Foo1()); container.Register<IBar>("bar1name", x => new Bar1()); container.Register<IFooBar>(y => new FooBar((IFoo)y.Resolve(typeof(IFoo)), (IBar)y.Resolve(typeof(IBar), "bar1name"))); container.Register<IFooBar>("foobarname", xyz => new FooBar(xyz.Resolve<IFoo>(), xyz.Resolve<IBar>("bar1name"))); // Act container.Compile(); var foo = container.Resolve<IFoo>(); var bar = container.Resolve<IBar>("bar1name"); var foobar1 = container.Resolve<IFooBar>(); var foobar2 = container.Resolve<IFooBar>("foobarname"); // Assert Assert.AreNotSame(foo, null); Assert.AreNotSame(bar, null); Assert.AreNotSame(foobar1, null); Assert.AreNotSame(foobar2, null); Assert.AreNotSame(foobar1.Foo, null); Assert.AreNotSame(foobar1.Bar, null); Assert.AreNotSame(foobar2.Foo, null); Assert.AreNotSame(foobar2.Bar, null); Assert.IsInstanceOfType(foo, typeof(Foo1)); Assert.IsInstanceOfType(bar, typeof(Bar1)); Assert.IsInstanceOfType(foobar1, typeof(FooBar)); Assert.IsInstanceOfType(foobar2, typeof(FooBar)); Assert.IsInstanceOfType(foobar1.Foo, typeof(Foo1)); Assert.IsInstanceOfType(foobar1.Bar, typeof(Bar1)); Assert.IsInstanceOfType(foobar2.Foo, typeof(Foo1)); Assert.IsInstanceOfType(foobar2.Bar, typeof(Bar1)); } }
public void CompileCanInlineRegistrationsWithContainerLifetime() { // Doesnt check that Compile actually works - just that it doesnt break anything using (var container = new IocContainer()) { container.Register <IFoo>(x => new Foo1()).WithContainerLifetime(); container.Register <IBar>(x => new Bar1()); var reg = container.Register <IFooBar>(x => new FooBar(x.Resolve <IFoo>(), x.Resolve <IBar>())); container.Compile(); var result1 = container.Resolve <IFoo>(); var result2 = (IFooBar)reg.GetInstance(); Assert.AreEqual(result1, result2.Foo); } }
public void CompileCanInlineInstanceRegistrations() { // Doesnt check that Compile actually works - just that it doesnt break anything using (var container = new IocContainer()) { var i1 = new Foo1(); var i2 = new Bar1(); container.RegisterInstance(i1); container.RegisterInstance(i2); var reg1 = container.Register <IFooBar>(x => new FooBar(x.Resolve <Foo1>(), x.Resolve <Bar1>())); container.Compile(); var result = (IFooBar)reg1.GetInstance(); Assert.AreEqual(i1, result.Foo); } }
public void CompileWorksWithNesting2() { using (var container = new IocContainer()) { // Arrange container.Register <IFoo, Foo1>().SetLifetime(new TransientLifetime()); container.Register <IBar, Bar1>().SetLifetime(new ContainerLifetime()); container.Register <IFooBar, FooBar>().WithContainerLifetime(); container.Register <IFooBarContainer, FooBarContainer>().WithContainerLifetime(); // Act container.Compile(); var fooBarContainer = container.Resolve <IFooBarContainer>(); // Assert Assert.IsNotNull(fooBarContainer); Assert.IsNotNull(fooBarContainer.FooBar); Assert.IsNotNull(fooBarContainer.FooBar.Foo); Assert.IsNotNull(fooBarContainer.FooBar.Bar); } }
public void RequestLifetimeWorksWithCompile() { using (var container = new IocContainer()) { // Arrange var context = new FakeHttpContext("Http://fakeUrl1.com"); var requestLifetime = new RequestLifetime(() => context, disposeOnEnd: false); // Do not test disposeOnEnd here container.Register <IFoo, Foo1>(); container.Register <IBar, Bar1>().SetLifetime(requestLifetime); container.Register <IFooBar, FooBar>(); // Act container.Compile(); var fooBar = container.Resolve <IFooBar>(); // Assert Assert.IsNotNull(fooBar); Assert.IsNotNull(fooBar.Foo); Assert.IsNotNull(fooBar.Bar); } }
public void RegisterAutoWorksWithCompileModeDynamicAndInternalCtor() { using (var container = new IocContainer()) { var reg1 = container.Register(typeof(IFoo), typeof(InternalFoo), compileMode: CompileMode.Dynamic, includeInternalCtor: true); var reg2 = container.Register(typeof(IFoo), typeof(InternalFoo), "TheKey", compileMode: CompileMode.Dynamic, includeInternalCtor: true); var reg3 = container.Register <InternalFoo, InternalFoo>(compileMode: CompileMode.Dynamic, includeInternalCtor: true); var reg4 = container.Register <InternalFoo, InternalFoo>("TheKey", compileMode: CompileMode.Dynamic, includeInternalCtor: true); container.Compile(); var instance1 = reg1.GetInstance(); var instance2 = reg2.GetInstance(); var instance3 = reg3.GetInstance(); var instance4 = reg4.GetInstance(); Assert.IsInstanceOfType(instance1, typeof(InternalFoo)); Assert.IsInstanceOfType(instance2, typeof(InternalFoo)); Assert.IsInstanceOfType(instance3, typeof(InternalFoo)); Assert.IsInstanceOfType(instance4, typeof(InternalFoo)); } }
public void CompileUsingKeyDoesntBreakUsingCompileModeDynamicWhenUsingInstanceRegistrationOrContainerLifetime() { // Test that InstanceRegistration and ContainerLifetime works using CompileMode Dynamic (should not be inlined) using (var container = new IocContainer(defaultCompileMode: CompileMode.Dynamic)) { var barInstance = new Bar1(); var reg1 = container.Register <IFoo, Foo1>("FirstKey").WithContainerLifetime(); var reg2 = container.RegisterInstance <IBar>(barInstance, "SecondKey"); var reg3 = container.Register <IFooBar>(x => new FooBar(x.Resolve <IFoo>("FirstKey"), x.Resolve <IBar>("SecondKey"))); container.Compile(); var res1 = container.Resolve <IFooBar>(); var res2 = container.Resolve <IFooBar>(); // Assert Assert.AreNotSame(res1, res2); Assert.AreSame(barInstance, res1.Bar); Assert.AreSame(res1.Foo, res2.Foo); } }
public void RegisterAutoWorksWithInternalProtectedCtor() { using (var container = new IocContainer()) { var reg1 = container.Register(typeof(IFoo), typeof(InternalProtectedFoo), compileMode: CompileMode.Delegate, includeInternalCtor: true); var reg2 = container.Register(typeof(IFoo), typeof(InternalProtectedFoo), "TheKey", compileMode: CompileMode.Delegate, includeInternalCtor: true); // Register as InternalProtectedFoo because default for IFoo is registered above var reg3 = container.Register <InternalProtectedFoo, InternalProtectedFoo>(compileMode: CompileMode.Delegate, includeInternalCtor: true); var reg4 = container.Register <InternalProtectedFoo, InternalProtectedFoo>("TheKey", compileMode: CompileMode.Delegate, includeInternalCtor: true); container.Compile(); var instance1 = reg1.GetInstance(); var instance2 = reg2.GetInstance(); var instance3 = reg3.GetInstance(); var instance4 = reg4.GetInstance(); Assert.IsInstanceOfType(instance1, typeof(InternalProtectedFoo)); Assert.IsInstanceOfType(instance2, typeof(InternalProtectedFoo)); Assert.IsInstanceOfType(instance3, typeof(InternalProtectedFoo)); Assert.IsInstanceOfType(instance4, typeof(InternalProtectedFoo)); } }
public void CompileWorksWithPropertyInjection() { // Can Resolve Property Injection !? // Make one using Resolve(Type) and one using Resolve<> generic ? // There need to be a check that the registration was actually compiled using (var container = new IocContainer()) { // Arrange container.Register<IFoo>(c => new Foo1()); container.Register<IBar>(c => new Bar1()); container.Register<IFooBar>(c => new FooBar() { Foo = c.Resolve<IFoo>(), Bar = c.Resolve<IBar>() }); // Act container.Compile(); var foo = container.Resolve<IFoo>(); var bar = container.Resolve<IBar>(); var foobar = container.Resolve<IFooBar>(); // Assert Assert.AreNotSame(foo, null); Assert.AreNotSame(bar, null); Assert.AreNotSame(foobar, null); Assert.AreNotSame(foobar.Foo, null); Assert.AreNotSame(foobar.Bar, null); } }
public void CompileThrowsExceptionIfRegistrationsAreNotValid() { using (var container = new IocContainer()) { // Arrange container.Register<IFoo>(c => new Foo1()); container.Register<IBar>("Bar", x => new Bar1()); container.Register<IFooBar>(y => new FooBar((IFoo)y.Resolve(typeof(IFoo)), (IBar)y.Resolve(typeof(IBar), "Bar"))); container.Register<IFooBar>("FooBar", xyz => new FooBar(xyz.Resolve<IFoo>(), xyz.Resolve<IBar>())); // Act container.Compile(); } }