public void ContainerTests_ChildContainer_Resolve_Dependency_Across_Childs_Wrapper()
{
var container = new StashboxContainer();
container.Register <ITest5, Test5>();
var child = container.CreateChildContainer();
child.Register <ITest2, Test2>();
var child2 = child.CreateChildContainer();
child2.Register <ITest3, Test3>();
var child3 = child2.CreateChildContainer();
child3.Register <ITest1, Test1>();
var test3 = child3.Resolve <ITest5>();
Assert.IsNotNull(test3);
Assert.IsNotNull(test3.Func());
Assert.IsNotNull(test3.Lazy.Value);
Assert.IsNotNull(test3.Enumerable);
Assert.AreEqual(1, test3.Enumerable.Count());
Assert.IsNotNull(test3.Tuple.Item1);
Assert.IsNotNull(test3.Tuple.Item2);
}
public void ContainerTests_CanResolve()
{
var container = new StashboxContainer();
container.RegisterType <ITest1, Test1>();
container.RegisterType <ITest2, Test2>();
var child = container.CreateChildContainer();
Assert.IsTrue(container.CanResolve <ITest1>());
Assert.IsTrue(container.CanResolve(typeof(ITest2)));
Assert.IsTrue(container.CanResolve <IEnumerable <ITest2> >());
Assert.IsTrue(container.CanResolve <Lazy <ITest2> >());
Assert.IsTrue(container.CanResolve <Func <ITest2> >());
Assert.IsTrue(container.CanResolve <Tuple <ITest2> >());
Assert.IsTrue(child.CanResolve <ITest1>());
Assert.IsTrue(child.CanResolve(typeof(ITest2)));
Assert.IsTrue(child.CanResolve <IEnumerable <ITest2> >());
Assert.IsTrue(child.CanResolve <Lazy <ITest2> >());
Assert.IsTrue(child.CanResolve <Func <ITest2> >());
Assert.IsTrue(child.CanResolve <Tuple <ITest2> >());
Assert.IsFalse(container.CanResolve <ITest3>());
Assert.IsFalse(container.CanResolve <ITest1>("test"));
Assert.IsFalse(container.CanResolve(typeof(ITest1), "test"));
}
public void EnumerableTests_Resolve_Parent_Lazy_Null()
{
IStashboxContainer container = new StashboxContainer();
var child = container.CreateChildContainer();
var all = child.Resolve <IEnumerable <Lazy <ITest1> > >();
Assert.Empty(all);
}
public void EnumerableTests_Resolve_Parent_Func_Null()
{
IStashboxContainer container = new StashboxContainer();
var child = container.CreateChildContainer();
var all = child.Resolve <IEnumerable <Func <ITest1> > >();
Assert.AreEqual(0, all.Count());
}
public void Verify_child_container_working()
{
var container = new StashboxContainer()
.RegisterSingleton <Singleton>()
.RegisterScoped <Scoped>();
Assert.Equal(1, container.Resolve <Singleton>().Id);
Assert.Equal(1, container.BeginScope().Resolve <Scoped>().Id);
var child = container.CreateChildContainer();
Assert.Equal(1, child.Resolve <Singleton>().Id);
Assert.Equal(2, child.BeginScope().Resolve <Scoped>().Id);
var child2 = container.CreateChildContainer().RegisterSingleton <Singleton>();
Assert.Equal(2, child2.Resolve <Singleton>().Id);
Assert.Equal(3, child2.BeginScope().Resolve <Scoped>().Id);
}
public void Ensure_Configuration_Change_Does_Not_Affect_Parent()
{
using var container = new StashboxContainer(c => c.WithLifetimeValidation());
Assert.True(container.ContainerContext.ContainerConfiguration.LifetimeValidationEnabled);
using var child = container.CreateChildContainer();
child.Configure(c => c.WithLifetimeValidation(false));
Assert.True(container.ContainerContext.ContainerConfiguration.LifetimeValidationEnabled);
Assert.False(child.ContainerContext.ContainerConfiguration.LifetimeValidationEnabled);
}
public void ContainerTests_ChildContainer_ResolveFromParent()
{
var container = new StashboxContainer();
container.Register <ITest1, Test1>();
var child = container.CreateChildContainer();
var test1 = child.Resolve <ITest1>();
Assert.NotNull(test1);
Assert.IsType <Test1>(test1);
}
public void NamedScope_ChildContainer(CompilerType compilerType)
{
var container = new StashboxContainer(c => c.WithCompiler(compilerType))
.Register <Test2>(config => config.DefinesScope("A"))
.Register <ITest, Test>(config => config.InNamedScope("A"));
var child = container.CreateChildContainer()
.Register <ITest, Test1>(config => config.InNamedScope("A"));
var inst = child.Resolve <Test2>();
Assert.IsType <Test1>(inst.Test);
}
public void NamedScope_ChildContainer()
{
var container = new StashboxContainer()
.Register <Test2>(config => config.DefinesScope("A"))
.Register <ITest, Test>(config => config.InNamedScope("A"));
var child = container.CreateChildContainer()
.Register <ITest, Test1>(config => config.InNamedScope("A"));
var inst = child.Resolve <Test2>();
Assert.IsInstanceOfType(inst.Test, typeof(Test1));
}
public void ContainerTests_ChildContainer_ResolveFromParent()
{
var container = new StashboxContainer();
container.RegisterType <ITest1, Test1>();
var child = container.CreateChildContainer();
var test1 = child.Resolve <ITest1>();
Assert.IsNotNull(test1);
Assert.IsInstanceOfType(test1, typeof(Test1));
}
public void NamedScope_ChildContainer_Chain_Reverse()
{
var container = new StashboxContainer()
.Register <Test4>(config => config.DefinesScope("A"))
.Register <ITest, Test1>(config => config.InNamedScope("B"));
var child = container.CreateChildContainer()
.Register <Test2>(config => config.DefinesScope("B").InNamedScope("A"));
var inst = child.Resolve <Test4>();
Assert.IsNotNull(inst.Test);
Assert.IsNotNull(inst.Test.Test);
}
public void EnumerableTests_Resolve_Parent_Lazy()
{
IStashboxContainer container = new StashboxContainer();
container.Register <ITest1, Test1>();
container.Register <ITest1, Test11>();
container.Register <ITest1, Test12>();
var child = container.CreateChildContainer();
var all = child.Resolve <IEnumerable <Lazy <ITest1> > >();
Assert.AreEqual(3, all.Count());
}
public void NamedScope_ChildContainer_Chain_Reverse(CompilerType compilerType)
{
var container = new StashboxContainer(c => c.WithCompiler(compilerType))
.Register(typeof(Test4), config => config.DefinesScope("A"))
.Register <ITest, Test1>(config => config.InNamedScope("B"));
var child = container.CreateChildContainer()
.Register <Test2>(config => config.DefinesScope("B").InNamedScope("A"));
var inst = child.Resolve <Test4>();
Assert.NotNull(inst.Test);
Assert.NotNull(inst.Test.Test);
}
public void ContainerTests_ChildContainer()
{
var container = new StashboxContainer();
container.RegisterType<ITest1, Test1>();
container.RegisterType<ITest2, Test2>();
var child = container.CreateChildContainer();
child.RegisterType<ITest3, Test3>();
var test3 = child.Resolve<ITest3>();
Assert.IsNotNull(test3);
Assert.IsInstanceOfType(test3, typeof(Test3));
Assert.AreEqual(container, child.ParentContainer);
}
public void ContainerTests_ChildContainer_Scoped()
{
var container = new StashboxContainer();
container.RegisterScoped <ITest1, Test1>();
var child = container.CreateChildContainer();
child.Register <ITest2, Test2>();
var test = child.BeginScope().Resolve <ITest2>();
Assert.NotNull(test);
Assert.IsType <Test2>(test);
}
public void ContainerTests_ChildContainer_Scoped()
{
var container = new StashboxContainer();
container.RegisterScoped <ITest1, Test1>();
var child = container.CreateChildContainer();
child.Register <ITest2, Test2>();
var test = child.Resolve <ITest2>();
Assert.IsNotNull(test);
Assert.IsInstanceOfType(test, typeof(Test2));
}
public void ContainerTests_ChildContainer_Resolve_Dependency_Across_Childs()
{
var container = new StashboxContainer();
container.Register <ITest3, Test3>();
var child = container.CreateChildContainer().CreateChildContainer();
child.Register <ITest1, Test1>();
child.Register <ITest2, Test2>();
var test3 = child.Resolve <ITest3>();
Assert.IsNotNull(test3);
}
public void EnumerableTests_Resolve_PreserveOrder_Parent_Func()
{
IStashboxContainer container = new StashboxContainer();
container.Register <ITest1, Test1>();
container.Register <ITest1, Test11>();
container.Register <ITest1, Test12>();
var child = container.CreateChildContainer();
var services = child.Resolve <IEnumerable <Func <ITest1> > >().ToArray();
Assert.IsInstanceOfType(services[0](), typeof(Test1));
Assert.IsInstanceOfType(services[1](), typeof(Test11));
Assert.IsInstanceOfType(services[2](), typeof(Test12));
}
public void EnumerableTests_Resolve_PreserveOrder_Parent_Lazy()
{
IStashboxContainer container = new StashboxContainer();
container.Register <ITest1, Test1>();
container.Register <ITest1, Test11>();
container.Register <ITest1, Test12>();
var child = container.CreateChildContainer();
var services = child.Resolve <IEnumerable <Lazy <ITest1> > >().ToArray();
Assert.IsType <Test1>(services[0].Value);
Assert.IsType <Test11>(services[1].Value);
Assert.IsType <Test12>(services[2].Value);
}
public void ContainerTests_ChildContainer()
{
var container = new StashboxContainer();
container.Register <ITest1, Test1>();
container.Register <ITest2, Test2>();
var child = container.CreateChildContainer();
child.Register <ITest3, Test3>();
var test3 = child.Resolve <ITest3>();
Assert.NotNull(test3);
Assert.IsType <Test3>(test3);
Assert.Equal(container.ContainerContext, child.ContainerContext.ParentContext);
}
public void ContainerTests_ChildContainer()
{
var container = new StashboxContainer();
container.RegisterType <ITest1, Test1>();
container.RegisterType <ITest2, Test2>();
var child = container.CreateChildContainer();
child.RegisterType <ITest3, Test3>();
var test3 = child.Resolve <ITest3>();
Assert.IsNotNull(test3);
Assert.IsInstanceOfType(test3, typeof(Test3));
Assert.AreEqual(container, child.ParentContainer);
}
public void ContainerTests_ChildContainer_Rebuild_Singletons_In_Child_Deps_Config_On_Child()
{
using var container = new StashboxContainer();
container.Register <ITest1, Test1>();
container.RegisterSingleton <Test2>();
var a = container.Resolve <Test2>();
Assert.IsType <Test1>(a.Test1);
using var child = container.CreateChildContainer(c => c.WithReBuildSingletonsInChildContainer());
child.Register <ITest1, Test11>();
var b = child.Resolve <Test2>();
Assert.IsType <Test11>(b.Test1);
}
public void ContextEstablishedInChildContainersCanBeAccessedWhenUsingAParentScopeConstructionWithChildContainer()
{
StashboxContainer sb1 = CreateContainer(c => c.WithScopedLifetime());
StashboxContainer sb2 = CreateContainer(c => c.WithScopedLifetime());
// This works
using var scope1 = sb1.BeginScope();
scope1.PutInstanceInScope(typeof(PrivateArgs <ITier2>), PrivateArgs <ITier2> .Get("Bob"));
scope1.PutInstanceInScope(typeof(PrivateArgs <TierBase>), PrivateArgs <TierBase> .Get(5));
ITier1 renderer = (ITier1)scope1.Resolve(typeof(ITier1));
// This fails
using var sbc = sb2.CreateChildContainer();
using var scope2 = sbc.BeginScope();
scope2.PutInstanceInScope(typeof(PrivateArgs <ITier2>), PrivateArgs <ITier2> .Get("Bob"));
scope2.PutInstanceInScope(typeof(PrivateArgs <TierBase>), PrivateArgs <TierBase> .Get(5));
ITier1 renderer2 = (ITier1)scope2.Resolve(typeof(ITier1));
}
public void ContainerTests_IsRegistered()
{
var container = new StashboxContainer();
container.RegisterType <ITest1, Test1>();
container.RegisterType <ITest2, Test2>(context => context.WithName("test"));
var child = container.CreateChildContainer();
Assert.IsTrue(container.IsRegistered <ITest1>());
Assert.IsTrue(container.IsRegistered <ITest2>("test"));
Assert.IsTrue(container.IsRegistered(typeof(ITest1)));
Assert.IsFalse(container.IsRegistered <IEnumerable <ITest1> >());
Assert.IsFalse(child.IsRegistered <ITest1>());
Assert.IsFalse(child.IsRegistered(typeof(ITest1)));
Assert.IsFalse(child.IsRegistered <IEnumerable <ITest1> >());
}
public void Verify_child_container_working_dispose()
{
Singleton s = null;
{
using var container = new StashboxContainer()
.RegisterSingleton <Singleton>();
{
{
using var child = container.CreateChildContainer();
s = child.Resolve <Singleton>();
}
Assert.False(s.Disposed);
}
}
Assert.True(s.Disposed);
}
public void ContainerTests_Throws_Disposed_Exceptions()
{
var container = new StashboxContainer();
container.Dispose();
Assert.Throws <ObjectDisposedException>(() => container.Activate(this.GetType()));
Assert.Throws <ObjectDisposedException>(() => container.BeginScope());
Assert.Throws <ObjectDisposedException>(() => container.BuildUp(new object()));
Assert.Throws <ObjectDisposedException>(() => container.CanResolve(this.GetType()));
Assert.Throws <ObjectDisposedException>(() => container.ComposeAssemblies(new[] { this.GetType().GetTypeInfo().Assembly }));
Assert.Throws <ObjectDisposedException>(() => container.ComposeAssembly(this.GetType().GetTypeInfo().Assembly));
Assert.Throws <ObjectDisposedException>(() => container.ComposeBy(this.GetType()));
Assert.Throws <ObjectDisposedException>(() => container.Configure(c => { }));
Assert.Throws <ObjectDisposedException>(() => container.CreateChildContainer());
Assert.Throws <ObjectDisposedException>(() => container.GetRegistrationMappings());
#if HAS_SERVICEPROVIDER
Assert.Throws <ObjectDisposedException>(() => container.GetService(this.GetType()));
#endif
Assert.Throws <ObjectDisposedException>(() => container.IsRegistered(this.GetType()));
Assert.Throws <ObjectDisposedException>(() => container.PutInstanceInScope(this.GetType()));
Assert.Throws <ObjectDisposedException>(() => container.Register(this.GetType()));
Assert.Throws <ObjectDisposedException>(() => container.RegisterAssemblies(new[] { this.GetType().GetTypeInfo().Assembly }));
Assert.Throws <ObjectDisposedException>(() => container.RegisterAssembly(this.GetType().GetTypeInfo().Assembly));
Assert.Throws <ObjectDisposedException>(() => container.RegisterAssemblyContaining <ITest1>());
Assert.Throws <ObjectDisposedException>(() => container.RegisterDecorator(this.GetType(), this.GetType()));
Assert.Throws <ObjectDisposedException>(() => container.RegisterFunc <ITest1>(r => new Test1()));
Assert.Throws <ObjectDisposedException>(() => container.RegisterInstance(new object()));
Assert.Throws <ObjectDisposedException>(() => container.RegisterInstances(new object()));
Assert.Throws <ObjectDisposedException>(() => container.RegisterResolver(null));
Assert.Throws <ObjectDisposedException>(() => container.RegisterScoped <ITest1, Test1>());
Assert.Throws <ObjectDisposedException>(() => container.RegisterSingleton <ITest1, Test1>());
Assert.Throws <ObjectDisposedException>(() => container.RegisterTypes(new [] { this.GetType() }));
Assert.Throws <ObjectDisposedException>(() => container.RegisterTypesAs <ITest1>(this.GetType().GetTypeInfo().Assembly));
Assert.Throws <ObjectDisposedException>(() => container.ReMap <ITest1, Test1>());
Assert.Throws <ObjectDisposedException>(() => container.ReMapDecorator(this.GetType(), this.GetType()));
Assert.Throws <ObjectDisposedException>(() => container.Resolve(this.GetType()));
Assert.Throws <ObjectDisposedException>(() => container.ResolveAll(this.GetType()));
Assert.Throws <ObjectDisposedException>(() => container.ResolveFactory(this.GetType()));
Assert.Throws <ObjectDisposedException>(() => container.Validate());
Assert.Throws <ObjectDisposedException>(() => container.WireUp(new object()));
}
public void DisposeTests_TrackTransientDisposal_Scoped_Transient_ChildContainer()
{
IStashboxContainer container = new StashboxContainer(config => config.WithDisposableTransientTracking());
ITest1 test4;
ITest2 test5;
Test3 test6;
container.Register <ITest2, Test2>();
container.Register <Test3>();
container.Register <ITest1, Test1>();
using (var child = container.CreateChildContainer())
using (var scope = child.BeginScope())
{
test4 = scope.Resolve <ITest1>();
test5 = scope.Resolve <ITest2>();
test6 = scope.Resolve <Test3>();
}
Assert.IsTrue(test4.Disposed);
Assert.IsTrue(test5.Test1.Disposed);
Assert.IsTrue(test6.Test1.Disposed);
}
public void BuildExtensionManagerTests_CreateCopy()
{
var post = new Mock <IRegistrationExtension>();
var post2 = new Mock <IRegistrationExtension>();
using (var container = new StashboxContainer())
{
container.RegisterExtension(post.Object);
post.Setup(p => p.CreateCopy()).Returns(post2.Object).Verifiable();
using (var child = container.CreateChildContainer())
{
child.RegisterInstanceAs(new object());
post2.Verify(p => p.Initialize(child.ContainerContext));
post2.Verify(p => p.OnRegistration(child.ContainerContext, It.IsAny <IServiceRegistration>()));
}
post2.Verify(p => p.CleanUp());
}
post.Verify(p => p.CleanUp());
}
public void BuildExtensionManagerTests_CreateCopy()
{
var post = new Mock<IRegistrationExtension>();
var post2 = new Mock<IRegistrationExtension>();
using (var container = new StashboxContainer())
{
container.RegisterExtension(post.Object);
post.Setup(p => p.CreateCopy()).Returns(post2.Object).Verifiable();
using (var child = container.CreateChildContainer())
{
child.RegisterInstance(new object());
post2.Verify(p => p.Initialize(child.ContainerContext));
post2.Verify(p => p.OnRegistration(child.ContainerContext,
It.IsAny<RegistrationInfo>(), null));
}
post2.Verify(p => p.CleanUp());
}
post.Verify(p => p.CleanUp());
}
public void ContainerTests_ChildContainer_Rebuild_Singletons_In_Child()
{
using var container = new StashboxContainer();
container.RegisterSingleton <ITest1, Test1>();
var a = container.Resolve <ITest1>();
var b = container.Resolve <ITest1>();
using var child = container.CreateChildContainer();
var c = child.Resolve <ITest1>();
Assert.Same(a, b);
Assert.Same(a, c);
Assert.Same(b, c);
child.Configure(c => c.WithReBuildSingletonsInChildContainer());
c = child.Resolve <ITest1>();
Assert.Same(a, b);
Assert.NotSame(a, c);
Assert.NotSame(b, c);
}