public void CollectsAllBindingsAndLoadsThemDistinctOnKernel() { var loadedModules = new List<INinjectModule>(); A.CallTo(() => this.kernel.Load(A<IEnumerable<INinjectModule>>._)) .Invokes((IEnumerable<INinjectModule> modules) => loadedModules.AddRange(modules)); var dependencyA = new DependencyA(); var dependencyB = new DependencyB(); var dependencyDefinitionA = new Dependency<IDependencyA>(bind => bind.ToConstant(dependencyA).InTransientScope()); var dependencyDefinitionB = new Dependency<IDependencyB>(bind => bind.ToConstant(dependencyB).InSingletonScope()); this.testee.Load( new FeatureA( dependencyDefinitionA, dependencyDefinitionB), new FeatureB( dependencyDefinitionA, dependencyDefinitionB), new FeatureC()); loadedModules.Select(_ => _.GetType().Name) .Should().Contain( new[] { typeof(ModuleA), typeof(ModuleB), typeof(ModuleC), typeof(ModuleD) }.Select(_ => _.Name)) .And.BeEquivalentTo(loadedModules.Select(_ => _.GetType().Name).Distinct()); }
public void The_Use_by_default_should_replace_previous_typed_registration() { var container = new Container(); var aa = new DependencyA(); container.Use(aa); Assert.AreSame(aa, container.Resolve <DependencyA>()); container.Use(new DependencyA()); Assert.AreNotSame(aa, container.Resolve <DependencyA>()); }
public void Can_keep_previous_default() { var container = new Container(); var aa = new DependencyA(); container.RegisterInstance(aa); container.RegisterInstance(new DependencyA(), IfAlreadyRegistered.Keep); var x = container.Resolve <DependencyA>(); Assert.AreSame(aa, x); }
public void Can_keep_previous_default_with_presence_of_keyed() { var container = new Container(); var aa = new DependencyA(); container.UseInstance(aa); container.UseInstance(aa, serviceKey: "aa"); container.UseInstance(new DependencyA(), ifAlreadyRegistered: IfAlreadyRegistered.Keep); var x = container.Resolve <DependencyA>(); Assert.AreSame(aa, x); }
public void Can_append_to_previous_typed_registration() { var container = new Container(); container.Register <DependencyA>(); var aa = new DependencyA(); container.UseInstance(aa, ifAlreadyRegistered: IfAlreadyRegistered.AppendNotKeyed); var aas = container.ResolveMany <DependencyA>(); Assert.AreEqual(2, aas.Count()); }
public void UseInstance_by_default_should_replace_previous_typed_registration() { var container = new Container(); container.Register <DependencyA>(); var aa = new DependencyA(); container.UseInstance(aa); var x = container.Resolve <DependencyA>(); Assert.AreSame(aa, x); }
public void TestChildDependencies() { IDependencyA dependency = new DependencyA(); IXrmContainer child = XrmContainer.Instance.CreateChild(); child.Register <IDependencyA>(dependency); IModuleA module = child.Resolve <IModuleA>(); Assert.AreSame(dependency, module.Dependency); IModuleA moduleParent = XrmContainer.Instance.Resolve <IModuleA>(); Assert.AreNotSame(dependency, moduleParent.Dependency); }
public void Can_append_to_previous_typed_registration() { var container = new Container(); container.Register <DependencyA>(); var aa = new DependencyA(); container.RegisterInstance(aa); var aas = container.ResolveMany <DependencyA>(); Assert.AreEqual(2, aas.Count()); }
public void Can_throw_on_previous_default() { var container = new Container(); var aa = new DependencyA(); container.RegisterInstance(aa); var ex = Assert.Throws <ContainerException>(() => container.RegisterInstance(new DependencyA(), IfAlreadyRegistered.Throw)); Assert.AreEqual( Error.NameOf(Error.UnableToRegisterDuplicateDefault), ex.ErrorName); }
public void Can_throw_on_previous_default_with_presence_of_keyed() { var container = new Container(); var aa = new DependencyA(); container.UseInstance(aa); container.UseInstance(aa, serviceKey: "aa"); var ex = Assert.Throws <ContainerException>(() => container.UseInstance(new DependencyA(), IfAlreadyRegistered.Throw)); Assert.AreEqual( Error.NameOf(Error.UnableToRegisterDuplicateDefault), Error.NameOf(ex.Error)); }
public void Can_append_new_default_implementation_And_ignore_the_duplicate_implementation() { var container = new Container(); var aa = new DependencyA(); container.RegisterInstance(aa); container.RegisterInstance <DependencyA>(new AAA(), IfAlreadyRegistered.AppendNewImplementation); Assert.AreEqual(2, container.ResolveMany <DependencyA>().Count()); var newaaa = new AAA(); container.RegisterInstance <DependencyA>(newaaa, IfAlreadyRegistered.AppendNewImplementation); container.RegisterInstance <DependencyA>(new AAAA(), IfAlreadyRegistered.AppendNewImplementation); Assert.AreEqual(3, container.ResolveMany <DependencyA>().Count()); }
public void Can_append_multiple_and_then_replace_all() { var container = new Container(); container.Register <DependencyA>(); var aa = new DependencyA(); container.RegisterInstance(aa, IfAlreadyRegistered.AppendNotKeyed); container.RegisterInstance <DependencyA>(new AAA(), IfAlreadyRegistered.AppendNotKeyed); var aas = container.ResolveMany <DependencyA>(); Assert.AreEqual(3, aas.Count()); container.RegisterInstance <DependencyA>(new AAAA(), IfAlreadyRegistered.Replace); var aaaa = container.Resolve <DependencyA>(); Assert.IsInstanceOf <AAAA>(aaaa); }
public void IoCRegInstancesBeforeBuildGraph() { var instanceA = new DependencyA(); IoCManager.RegisterInstance <DependencyA>(instanceA, deferInject: true); var instanceB = new DependencyB(); IoCManager.RegisterInstance <DependencyB>(instanceB, deferInject: true); IoCManager.BuildGraph(); var resolveA = IoCManager.Resolve <DependencyA>(); var resolveB = IoCManager.Resolve <DependencyB>(); Assert.That(instanceA, Is.EqualTo(resolveA)); Assert.That(instanceB, Is.EqualTo(resolveB)); Assert.That(resolveA._depB, Is.EqualTo(resolveB)); Assert.That(resolveB._depA, Is.EqualTo(resolveA)); }
public void UseInstance_wont_replace_existing_typed_registration_instead_will_append_to_it_In_presence_or_keyed_registration() { var container = new Container(); container.Register <ServiceB>(); container.Register <DependencyA>(serviceKey: "other"); container.Register <DependencyA>(); var dependencyA = new DependencyA(); ServiceB service; using (var scope = container.OpenScope()) { scope.Use(dependencyA); service = scope.Resolve <ServiceB>(); Assert.AreSame(dependencyA, service.Dep); } service = container.Resolve <ServiceB>(); Assert.IsNotNull(service.Dep); Assert.AreNotSame(dependencyA, service.Dep); }
public void Singleton_service_should_consume_singleton_instance_despite_presence_of_scoped_instance() { var container = new Container(); container.Register <ServiceB>(Reuse.Singleton); var singletonDep = new DependencyA(); container.Use(singletonDep); using (var scope = container.OpenScope()) { var scopedDep = new DependencyA(); scope.Use(scopedDep); var service = scope.Resolve <ServiceB>(); Assert.AreSame(singletonDep, service.Dep); } var anotherBB = container.Resolve <ServiceB>(); Assert.AreSame(singletonDep, anotherBB.Dep); }
public void The_used_instance_dependency_should_be_independent_of_scope() { var container = new Container(); container.Register <ServiceB>(); var singletonDep = new DependencyA(); container.Use(singletonDep); using (var scope = container.OpenScope()) { var scopedDep = new DependencyA(); scope.Use(scopedDep); var service = scope.Resolve <ServiceB>(); Assert.AreSame(scopedDep, service.Dep); } var anotherBB = container.Resolve <ServiceB>(); Assert.AreSame(singletonDep, anotherBB.Dep); }
public void UseInstance_wont_replace_existing_typed_registration_instead_will_append_to_it() { var container = new Container(); container.Register <ServiceB>(); container.Register <DependencyA>(); var dependencyA = new DependencyA(); ServiceB service; using (var scope = container.OpenScope()) { scope.Use(dependencyA); // what does it mean for the typed DependencyA service = scope.Resolve <ServiceB>(); Assert.AreSame(dependencyA, service.Dep); } service = container.Resolve <ServiceB>(); Assert.IsNotNull(service.Dep); Assert.AreNotSame(dependencyA, service.Dep); }
public Container(DependencyA depA, DependencyB depB) { this.depA = depA; this.depB = depB; }
public HomeController(DependencyA dependencyA) { this.dependencyA = dependencyA; }
public void ExecutesAllDistinctDependencies() { var dependencyA = new DependencyA(); var dependencyB = new DependencyB(); var dependencyDefinitionA = new Dependency<IDependencyA>(bind => bind.ToConstant(dependencyA).InTransientScope()); this.testee.Load( new FeatureA( dependencyDefinitionA, new Dependency<IDependencyB>(bind => bind.ToConstant(dependencyB).InSingletonScope())), new FeatureB( dependencyDefinitionA, new Dependency<IDependencyB>(bind => bind.ToConstant(dependencyB).InSingletonScope())), new FeatureC()); A.CallTo(() => this.kernel.Bind<IDependencyA>()).MustHaveHappened(); A.CallTo(() => this.kernel.Bind<IDependencyB>()).MustHaveHappened(); }
public void CollectsAllExtensionsAndLoadsThemDistinctBeforeLoadingModules() { var loadedModules = new List<INinjectModule>(); A.CallTo(() => this.kernel.Load(A<IEnumerable<INinjectModule>>._)) .Invokes((IEnumerable<INinjectModule> modules) => loadedModules.AddRange(modules)); var dependencyA = new DependencyA(); var dependencyB = new DependencyB(); var dependencyDefinitionA = new Dependency<IDependencyA>(bind => bind.ToConstant(dependencyA).InTransientScope()); var dependencyDefinitionB = new Dependency<IDependencyB>(bind => bind.ToConstant(dependencyB).InSingletonScope()); this.testee.Load( new FeatureA( dependencyDefinitionA, dependencyDefinitionB), new FeatureB( dependencyDefinitionA, dependencyDefinitionB)); loadedModules.Select(m => m.GetType().Name) .Should().ContainInOrder( new[] { typeof(ExtensionModuleA), typeof(ExtensionModuleB), typeof(ExtensionModuleC), typeof(ModuleA), typeof(ModuleB), typeof(ModuleC), }.Select(_ => _.Name)) .And.HaveCount(6); }
public DependencyBImpl(DependencyA depA) { this.depA = depA; }
public InjectedTestClassCommandTests(DependencyA dependency) { _dependency = dependency; }
public Container ProvidesContainer(DependencyA depA, DependencyB depB) { return Container = new Container(depA, depB); }
public TypeToBeActivated(DependencyA a, DependencyB b, DependencyC c) { }
public WithDependenciesCommand(DependencyA dependencyA, DependencyB dependencyB, DependencyC dependencyC) { _dependencyA = dependencyA; _dependencyB = dependencyB; _dependencyC = dependencyC; }
public Container ProvidesContainer(DependencyA depA, DependencyB depB) { return(Container = new Container(depA, depB)); }
public WithDependenciesCommand(DependencyA dependencyA, DependencyB dependencyB) { _dependencyA = dependencyA; _dependencyB = dependencyB; }
public void HandleTestCommand(Ns06_TestCommand command) { command.Param = DependencyA.GetTestValue() == "A" && DependencyB == null && DependencyC != null ? 1 : 0; }
public ServiceB(DependencyA dep) { Dep = dep; }