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