public void StandardResolveTests_Resolve_Scoped_Injection_Factory() { using IStashboxContainer container = new StashboxContainer(); container.RegisterScoped(typeof(ITest1), typeof(Test1)); container.RegisterScoped <ITest4, Test4>(); using var scope = container.BeginScope(); var factory = scope.ResolveFactory <ITest4>(); var inst = factory(); var inst2 = factory(); Assert.Same(inst.Test, inst2.Test); Assert.Same(inst.Test2, inst2.Test2); Assert.Same(inst.Test, inst2.Test2); using var child = container.BeginScope(); var scopedFactory = child.ResolveFactory <ITest4>(); var inst3 = scopedFactory(); var inst4 = scopedFactory(); Assert.NotSame(inst.Test, inst4.Test); Assert.NotSame(inst.Test2, inst4.Test2); Assert.NotSame(inst.Test, inst4.Test2); Assert.Same(inst3.Test, inst4.Test); Assert.Same(inst3.Test2, inst4.Test2); Assert.Same(inst3.Test, inst4.Test2); }
public void LifetimeTests_Scoped_Is_Not_Resolvable_From_Root_AfterResolved(bool enabledValidation) { using IStashboxContainer container = new StashboxContainer(c => { if (enabledValidation) { c.WithLifetimeValidation(); } }); container.Register <Test6>(); container.RegisterScoped <Test5>(); if (enabledValidation) { using var scope = container.BeginScope(); scope.Resolve <Test6>(); var exception = Assert.Throws <LifetimeValidationFailedException>(() => container.Resolve <Test6>()); Assert.Contains("from the root scope", exception.Message); } else { using var scope = container.BeginScope(); scope.Resolve <Test6>(); Assert.NotNull(container.Resolve <Test6>()); } }
public void Ensure_Named_Scoped_Instance_Working() { using var container = new StashboxContainer() .Register <A>(); var a1 = new A(); var a2 = new A(); var a3 = new A(); { using var scope = container.BeginScope(); scope.PutInstanceInScope(a1); scope.PutInstanceInScope(a2, name: "a"); scope.PutInstanceInScope(a2); Assert.Same(a2, scope.Resolve <A>("a")); } { using var scope = container.BeginScope(); scope.PutInstanceInScope(a1, name: "a1"); scope.PutInstanceInScope(a2, name: "a2"); scope.PutInstanceInScope(a2, name: "a3"); Assert.Same(a2, scope.Resolve <A>("a2")); } }
public void DisposeTests_PutInScope_Scoped() { using IStashboxContainer container = new StashboxContainer(); container.RegisterScoped <ITest2, Test2>(); container.RegisterScoped <Test3>(); var test = new Test1(); using (var child = container.BeginScope()) { child.PutInstanceInScope <ITest1>(test); var test1 = child.Resolve <ITest1>(); var test2 = child.Resolve <ITest2>(); var test3 = child.Resolve <Test3>(); Assert.Same(test, test1); Assert.Same(test, test2.Test1); Assert.Same(test, test3.Test1); Assert.False(test.Disposed); } Assert.True(test.Disposed); var test4 = new Test1(); using (var child = container.BeginScope()) { child.PutInstanceInScope <ITest1>(test4); var test1 = child.Resolve <ITest1>(); var test2 = child.Resolve <ITest2>(); var test3 = child.Resolve <Test3>(); Assert.Same(test4, test1); Assert.Same(test4, test2.Test1); Assert.Same(test4, test3.Test1); Assert.NotSame(test, test1); Assert.NotSame(test, test2.Test1); Assert.NotSame(test, test3.Test1); Assert.False(test4.Disposed); } Assert.True(test4.Disposed); }
public void NamedScope_Cache(CompilerType compilerType) { var container = new StashboxContainer(c => c.WithCompiler(compilerType)) .Register <ITest, Test>(config => config.InNamedScope("A")) .Register <ITest, Test1>(); using var scope = container.BeginScope(); var inst = scope.Resolve <ITest>(); Assert.IsType <Test1>(inst); using var scope1 = container.BeginScope("A"); inst = scope1.Resolve <ITest>(); Assert.IsType <Test>(inst); }
public void LifetimeTests_Scoped_WithNull() { using IStashboxContainer container = new StashboxContainer(); container.RegisterScoped <Test6>(); Assert.Null(container.BeginScope().Resolve <Test6>(nullResultAllowed: true)); }
public void StandardResolveTests_Resolve_Scoped_Injection() { using (IStashboxContainer container = new StashboxContainer()) { container.RegisterScoped(typeof(ITest1), typeof(Test1)); container.RegisterScoped <ITest4, Test4>(); var inst = container.Resolve <ITest4>(); var inst2 = container.Resolve <ITest4>(); Assert.AreSame(inst.Test, inst2.Test); Assert.AreSame(inst.Test2, inst2.Test2); Assert.AreSame(inst.Test, inst2.Test2); using (var child = container.BeginScope()) { var inst3 = child.Resolve <ITest4>(); var inst4 = child.Resolve <ITest4>(); Assert.AreNotSame(inst.Test, inst4.Test); Assert.AreNotSame(inst.Test2, inst4.Test2); Assert.AreNotSame(inst.Test, inst4.Test2); Assert.AreSame(inst3.Test, inst4.Test); Assert.AreSame(inst3.Test2, inst4.Test2); Assert.AreSame(inst3.Test, inst4.Test2); } } }
public void RegisteredInstancesCanBeOverridenViaAFactory() { var container = new StashboxContainer(); var toInclude = new A { Id = 20 }; container.RegisterInstance(toInclude); var outer = container.Resolve <A>(); A inner1 = null; A inner2 = null; using (var scope = container.BeginScope()) { inner1 = scope.Resolve <A>(); var toOverride = new A { Id = 30 }; scope.PutInstanceInScope(toOverride); inner2 = scope.Resolve <A>(); } Assert.Equal(toInclude.Id, outer.Id); Assert.Equal(toInclude.Id, inner1.Id); Assert.Equal(30, inner2.Id); }
public void LifetimeTests_Shorter_Lifetime_Not_Resolvable_From_Longer_InDirect(bool enabledValidation) { using IStashboxContainer container = new StashboxContainer(c => { if (enabledValidation) { c.WithLifetimeValidation(); } }); container.RegisterSingleton <Test8>(); container.Register <Test6>(); container.RegisterScoped <Test5>(); using var scope = container.BeginScope(); if (enabledValidation) { var exception = Assert.Throws <LifetimeValidationFailedException>(() => scope.Resolve <Test8>()); Assert.Contains("The life-span of", exception.Message); } else { Assert.NotNull(scope.Resolve <Test8>()); } }
public void DisposeTests_TrackTransientDisposal_Scoped_Transient_Singleton() { var container = new StashboxContainer(config => config.WithDisposableTransientTracking()); container.Register <ITest2, Test2>(); container.Register <Test3>(); container.RegisterSingleton <ITest1, Test1>(); ITest1 test4; ITest2 test5; Test3 test6; using (var child = container.BeginScope()) { test4 = child.Resolve <ITest1>(); test5 = child.Resolve <ITest2>(); test6 = child.Resolve <Test3>(); Assert.IsFalse(test4.Disposed); Assert.IsFalse(test5.Test1.Disposed); Assert.IsFalse(test6.Test1.Disposed); } Assert.IsFalse(test4.Disposed); Assert.IsFalse(test5.Test1.Disposed); Assert.IsFalse(test6.Test1.Disposed); container.Dispose(); Assert.IsTrue(test4.Disposed); Assert.IsTrue(test5.Test1.Disposed); Assert.IsTrue(test6.Test1.Disposed); }
public void Ensure_expression_built_correctly_singleton_dispose_simple(CompilerType compilerType) { C.Counter = 0; F inst = null; { using var container = new StashboxContainer(c => { c.WithDisposableTransientTracking().WithCompiler(compilerType); }) .Register <F>(c => c.WithScopedLifetime()) .Register <C>(c => c.WithSingletonLifetime()); { using var scope = container.BeginScope(); inst = scope.Resolve <F>(); } Assert.True(inst.Disposed); Assert.False(inst.C.Disposed); } Assert.True(inst.C.Disposed); Assert.Equal(1, C.Counter); }
public void DisposeTests_PutInScope_WithoutDispose() { using (IStashboxContainer container = new StashboxContainer()) { container.Register <ITest2, Test2>(); container.Register <Test3>(); var test = new Test1(); using (var child = container.BeginScope()) { child.PutInstanceInScope <ITest1>(test, true); var test1 = child.Resolve <ITest1>(); var test2 = child.Resolve <ITest2>(); var test3 = child.Resolve <Test3>(); Assert.AreSame(test, test1); Assert.AreSame(test, test2.Test1); Assert.AreSame(test, test3.Test1); } Assert.IsFalse(test.Disposed); } }
public void NamedScope_WithNull() { var container = new StashboxContainer() .RegisterType <Test2>(config => config.InNamedScope("A")); Assert.IsNull(container.BeginScope("A").Resolve <Test2>(nullResultAllowed: true)); }
public void RegistersTests_Registers_Configurator() { IStashboxContainer container = new StashboxContainer(); container.RegisterTypes(new[] { typeof(Test), typeof(Test1), typeof(Test11), typeof(Test12) }, configurator: context => { if (context.ServiceType == typeof(ITest2)) { context.WithScopedLifetime(); } }); using var scope = container.BeginScope(); var test = scope.ResolveAll <ITest>(); var test1 = scope.ResolveAll <ITest1>(); var test2 = scope.ResolveAll <ITest2>(); var scopeds = container.ContainerContext.RegistrationRepository.GetRegistrationMappings().Where(r => r.Value.RegistrationContext.Lifetime is ScopedLifetime).ToArray(); Assert.Equal(3, test.Count()); Assert.Equal(3, test1.Count()); Assert.Equal(2, test2.Count()); Assert.Equal(2, scopeds.Length); }
public void BuildUpTests_BuildUp_Scoped() { using (var container = new StashboxContainer()) { container.RegisterScoped <ITest, Test>(); var test1 = new Test1(); var test2 = new Test2(); using (var scope = container.BeginScope()) { container.WireUpAs <ITest1>(test1); var inst = scope.BuildUp(test2); Assert.AreEqual(test2, inst); Assert.IsNotNull(inst); Assert.IsNotNull(inst.Test1); Assert.IsInstanceOfType(inst, typeof(Test2)); Assert.IsInstanceOfType(inst.Test1, typeof(Test1)); Assert.IsInstanceOfType(inst.Test1.Test, typeof(Test)); } Assert.IsTrue(test1.Test.Disposed); Assert.IsTrue(test2.Test1.Test.Disposed); } }
public void Ensure_expression_built_correctly_scoped(CompilerType compilerType) { A.Counter = 0; B.Counter = 0; C.Counter = 0; D.Counter = 0; E.Counter = 0; F.Counter = 0; A inst = null; { using var container = new StashboxContainer(c => c.WithRuntimeCircularDependencyTracking() .WithDisposableTransientTracking() .WithCompiler(compilerType)) .Register <A>(c => c.WithScopedLifetime()) .Register <B>(c => c.WithScopedLifetime()) .Register <D>(c => c.WithScopedLifetime()) .Register <E>(c => c.WithScopedLifetime()) .Register <F>(c => c.WithScopedLifetime()) .Register <C>(c => c.WithFactory(r => new C()).WithScopedLifetime().WithoutDisposalTracking()); using var scope = container.BeginScope(); inst = scope.Resolve <A>(); Assert.NotNull(inst); Assert.NotNull(inst.B); Assert.NotNull(inst.C); Assert.NotNull(inst.B.D); Assert.NotNull(inst.B.C); Assert.NotNull(inst.B.D.C); Assert.NotNull(inst.B.D.E); Assert.NotNull(inst.B.D.F); Assert.NotNull(inst.B.D.E.C); Assert.NotNull(inst.B.D.F.C); Assert.Same(inst.C, inst.B.C); Assert.Same(inst.B.C, inst.B.D.C); Assert.Same(inst.B.D.C, inst.B.D.E.C); Assert.Same(inst.B.D.E.C, inst.B.D.F.C); } Assert.True(inst.Disposed); Assert.True(inst.B.Disposed); Assert.False(inst.C.Disposed); Assert.True(inst.B.D.Disposed); Assert.False(inst.B.C.Disposed); Assert.False(inst.B.D.C.Disposed); Assert.True(inst.B.D.E.Disposed); Assert.True(inst.B.D.F.Disposed); Assert.False(inst.B.D.E.C.Disposed); Assert.False(inst.B.D.F.C.Disposed); Assert.Equal(1, A.Counter); Assert.Equal(1, B.Counter); Assert.Equal(1, C.Counter); Assert.Equal(1, D.Counter); Assert.Equal(1, E.Counter); Assert.Equal(1, F.Counter); }
public void GenericTests_Resolve_Prefer_Open_Generic_Enumerable_In_Named_Scope() { var container = new StashboxContainer(config => config.WithUniqueRegistrationIdentifiers()) .RegisterType <ITest1 <int, string>, Test1 <int, string> >(config => config.InNamedScope("A")) .RegisterType(typeof(ITest1 <,>), typeof(Test1 <,>), config => config.InNamedScope("A")); var res = container.BeginScope("A").Resolve <IEnumerable <ITest1 <int, string> > >(); Assert.AreEqual(2, res.Count()); }
public void StandardResolveTests_Factory_Scoped() { using IStashboxContainer container = new StashboxContainer(); container.Register <ITest1, Test1>(); using var child = container.BeginScope(); var test1 = child.ResolveFactory(typeof(ITest1)).DynamicInvoke(); Assert.NotNull(test1); Assert.IsType <Test1>(test1); }
public void EnumerableTests_Resolve_Scoped_Lazy_Null() { IStashboxContainer container = new StashboxContainer(); var child = container.BeginScope(); var all = child.Resolve <IEnumerable <Lazy <ITest1> > >(); Assert.Empty(all); }
public void GenericTests_Resolve_Prefer_Open_Generic_In_Named_Scope() { var container = new StashboxContainer(config => config.WithUniqueRegistrationIdentifiers()) .RegisterType <ITest1 <int, string>, Test1 <int, string> >() .RegisterType(typeof(ITest1 <,>), typeof(Test1 <,>), config => config.InNamedScope("A")); container.BeginScope("A").Resolve <ITest1 <int, string> >(); Assert.AreEqual(3, container.ContainerContext.RegistrationRepository.GetAllRegistrations().Count()); }
public void StandardResolveTests_Resolve_Scoped() { using IStashboxContainer container = new StashboxContainer(); container.RegisterScoped <ITest1, Test1>(); using var scope = container.BeginScope(); var inst = scope.Resolve <ITest1>(); var inst2 = scope.Resolve <ITest1>(); Assert.Same(inst, inst2); using var child = container.BeginScope(); var inst3 = child.Resolve <ITest1>(); var inst4 = child.Resolve <ITest1>(); Assert.NotSame(inst, inst3); Assert.Same(inst3, inst4); }
public void StandardResolveTests_Ensure_DependencyResolver_CanBeResolved() { using IStashboxContainer container = new StashboxContainer(); container.RegisterScoped <ResolverTest>(); using var scope = container.BeginScope(); var resolver = scope.Resolve <IDependencyResolver>(); var test = scope.Resolve <ResolverTest>(); Assert.Same(resolver, test.DependencyResolver); using var scope1 = container.BeginScope(); var scopedResolver = scope1.Resolve <IDependencyResolver>(); var test1 = scope1.Resolve <ResolverTest>(); Assert.Same(scope1, scopedResolver); Assert.Same(scope1, test1.DependencyResolver); }
public void ResolveFactoryTests_ParameterLess_Scoped(CompilerType compilerType) { using var container = new StashboxContainer(c => c.WithCompiler(compilerType)); container.Register <Test>(); using var scope = container.BeginScope(); var factory = scope.ResolveFactory <Test>(); Assert.NotNull(factory()); }
public void EnumerableTests_Resolve_Scoped_Func_Null() { IStashboxContainer container = new StashboxContainer(); var child = container.BeginScope(); var all = child.Resolve <IEnumerable <Func <ITest1> > >(); Assert.AreEqual(0, all.Count()); }
public void FactoryTests_Resolve_Gets_The_Proper_Scope(CompilerType compilerType) { using var container = new StashboxContainer(c => c.WithCompiler(compilerType)); container.Register <Test5>(context => context.WithFactory(resolver => new Test5(resolver))); using var scope = container.BeginScope(); var t = scope.Resolve <Test5>(); Assert.Same(scope, t.DependencyResolver); }
public void GenericTests_Resolve_Prefer_Open_Generic_In_Named_Scope() { var container = new StashboxContainer(config => config .WithRegistrationBehavior(Rules.RegistrationBehavior.PreserveDuplications)) .Register <ITest1 <int, string>, Test1 <int, string> >() .Register(typeof(ITest1 <,>), typeof(Test1 <,>), config => config.InNamedScope("A")); container.BeginScope("A").Resolve <ITest1 <int, string> >(); Assert.Equal(2, container.ContainerContext.RegistrationRepository.GetRegistrationMappings().Count()); }
public void GenericTests_Resolve_Prefer_Open_Generic_Enumerable_In_Named_Scope() { var container = new StashboxContainer(config => config .WithRegistrationBehavior(Rules.RegistrationBehavior.PreserveDuplications)) .Register <ITest1 <int, string>, Test1 <int, string> >(config => config.InNamedScope("A")) .Register(typeof(ITest1 <,>), typeof(Test1 <,>), config => config.InNamedScope("A")); var res = container.BeginScope("A").Resolve <IEnumerable <ITest1 <int, string> > >(); Assert.Equal(2, res.Count()); }
public void DisposeTests_Scoped() { ITest1 test; ITest2 test2; Test3 test3; using (IStashboxContainer container = new StashboxContainer()) { ITest1 test4; ITest2 test5; Test3 test6; container.RegisterScoped <ITest2, Test2>(); container.RegisterScoped <Test3>(); container.RegisterScoped <ITest1, Test1>(); container.RegisterScoped <ITest11, Test4>(); container.RegisterScoped <ITest1, Test1>("test"); container.RegisterScoped <ITest11, Test4>("test2"); using var scope = container.BeginScope(); test = scope.Resolve <ITest1>(); var a = scope.Resolve <ITest11>(); test2 = scope.Resolve <ITest2>(); test3 = scope.Resolve <Test3>(); using (var child = container.BeginScope()) { test4 = (ITest1)child.Resolve(typeof(ITest1), "test"); test5 = child.Resolve <ITest2>(); test6 = child.Resolve <Test3>(); } Assert.True(test4.Disposed); Assert.True(test5.Test1.Disposed); Assert.True(test6.Test1.Disposed); } Assert.True(test.Disposed); Assert.True(test2.Test1.Disposed); Assert.True(test3.Test1.Disposed); }
public void EnumerableTests_Resolve_Scoped_Null() { IStashboxContainer container = new StashboxContainer(); var scope = container.BeginScope(); var all = scope.Resolve <IEnumerable <ITest2> >(); var all2 = scope.ResolveAll <ITest2>(); Assert.Empty(all); Assert.Empty(all2); }
public void EnumerableTests_Resolve_Scoped_Null() { IStashboxContainer container = new StashboxContainer(); var scope = container.BeginScope(); var all = scope.Resolve <IEnumerable <ITest2> >(); var all2 = scope.ResolveAll <ITest2>(); Assert.AreEqual(0, all.Count()); Assert.AreEqual(0, all2.Count()); }