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