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);
        }
Exemple #2
0
        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>());
            }
        }
Exemple #3
0
        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"));
            }
        }
Exemple #4
0
        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);
        }
Exemple #5
0
        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);
        }
Exemple #6
0
        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);
        }
Exemple #9
0
        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>());
            }
        }
Exemple #10
0
        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);
        }
Exemple #11
0
        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);
        }
Exemple #12
0
        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);
            }
        }
Exemple #13
0
        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);
        }
Exemple #15
0
        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);
            }
        }
Exemple #16
0
        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);
        }
Exemple #17
0
        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);
        }
Exemple #19
0
        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);
        }
Exemple #20
0
        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());
        }
Exemple #24
0
        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());
        }
Exemple #25
0
        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);
        }
Exemple #26
0
        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());
        }
Exemple #27
0
        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());
        }
Exemple #28
0
        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);
        }
Exemple #29
0
        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);
        }
Exemple #30
0
        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());
        }