public void OneInstancedBindingsTypeWithDefaultConstructorSucceedsIfCircularDependencies() { var first = new DefaultConstructorCircularDependency(null); var second = new DefaultConstructorCircularDependencyOther(first); var container = new ExtraContainer1(); container.Bind <BaseClass, DefaultConstructorCircularDependency>("First"); container.Bind <BaseClass, DefaultConstructorCircularDependencyOther>("Second", second); var firstResolved = container.Resolve <BaseClass>("First") as DefaultConstructorCircularDependency; Assert.NotNull(firstResolved); var secondResolved = firstResolved.BaseClass as DefaultConstructorCircularDependencyOther; Assert.NotNull(secondResolved); var firstCircularResolved = secondResolved.BaseClass as DefaultConstructorCircularDependency; Assert.NotNull(firstCircularResolved); var secondShouldBePassedIn = firstCircularResolved.BaseClass; Assert.IsNull(secondShouldBePassedIn); Assert.AreNotEqual(firstResolved, firstCircularResolved); Assert.AreEqual(second, secondResolved); }
public void CanMakeValidBindings() { Context.Dispose(); var container = new ExtraContainer1(); container.Bind <Interface, ConcreteInterface>(); container.Bind <AbstractClass, ConcreteAbstractClass>(); container.Bind <BaseClass, SubClass>(); container.Bind <Interface, ConcreteInterface>("First"); container.Bind <AbstractClass, ConcreteAbstractClass>("Second"); container.Bind <BaseClass, SubClass>("Third"); int index = 0; var bindings = container.GetBindings(); Assert.AreEqual(6, bindings.Count); Assert.AreEqual(string.Empty, bindings[index].Item1); Assert.AreSame(typeof(Interface), bindings[index].Item2.TypeBoundFrom); Assert.AreSame(typeof(ConcreteInterface), bindings[index].Item2.TypeBoundTo); Assert.AreEqual("First", bindings[++index].Item1); Assert.AreSame(typeof(Interface), bindings[index].Item2.TypeBoundFrom); Assert.AreSame(typeof(ConcreteInterface), bindings[index].Item2.TypeBoundTo); Assert.AreEqual(string.Empty, bindings[++index].Item1); Assert.AreSame(typeof(AbstractClass), bindings[index].Item2.TypeBoundFrom); Assert.AreSame(typeof(ConcreteAbstractClass), bindings[index].Item2.TypeBoundTo); Assert.AreEqual("Second", bindings[++index].Item1); Assert.AreSame(typeof(AbstractClass), bindings[index].Item2.TypeBoundFrom); Assert.AreSame(typeof(ConcreteAbstractClass), bindings[index].Item2.TypeBoundTo); Assert.AreEqual(string.Empty, bindings[++index].Item1); Assert.AreSame(typeof(BaseClass), bindings[index].Item2.TypeBoundFrom); Assert.AreSame(typeof(SubClass), bindings[index].Item2.TypeBoundTo); Assert.AreEqual("Third", bindings[++index].Item1); Assert.AreSame(typeof(BaseClass), bindings[index].Item2.TypeBoundFrom); Assert.AreSame(typeof(SubClass), bindings[index].Item2.TypeBoundTo); }
public void DisposeProperlyClearsContainers() { var container2 = new ExtraContainer1(); container2.Bind <BaseClass, SubClassWithFieldDependencies>(); container2.Bind <Interface, ConcreteInterface>("First").AsSingleton(); container2.Bind <Interface, ConcreteInterface>(); var abstractClass = _container.Resolve <AbstractClass>(); var baseClass = container2.Resolve <BaseClass>(); var bindings = container2.GetBindings(); var binding = bindings.FirstOrDefault(t => t.Item2.TypeBoundFrom == typeof(BaseClass))?.Item2; var bindingInterface = bindings.FirstOrDefault(t => t.Item1 == "First")?.Item2; var dependencies = binding?.GetDependencies(); Assert.NotNull(baseClass); Assert.NotNull(abstractClass); Assert.NotNull(bindings); Assert.NotNull(binding); Assert.NotNull(bindingInterface); Assert.NotNull(dependencies); Assert.AreEqual(3, bindings.Count); Assert.AreEqual(2, dependencies.Count); Assert.IsTrue(bindingInterface.HasInstanceAvailable()); Context.Dispose(); Assert.Throws <Exception>(() => Context.GetContainerByType <ExtraContainer1>()); Assert.Throws <Exception>(() => Context.GetContainerByType(typeof(ExtraContainer1))); Assert.Throws <Exception>(() => _container.Resolve <AbstractClass>()); Assert.IsFalse(bindingInterface.HasInstanceAvailable()); Assert.AreEqual(0, _container.GetBindings().Count); }
public void DisposedInheritedContainersNoLongerResolveBindings() { var parentContainer = new ExtraContainer1(); parentContainer.Bind <Interface, ConcreteInterface>().AsSingleton(); parentContainer.Bind <AbstractClass, ConcreteAbstractClass>(); var container = new ExtraContainer2(typeof(ExtraContainer1)); container.Bind <Interface, ConcreteInterface>().AsSingleton(); var abstractClass = container.Resolve <AbstractClass>(); var parentInterface = parentContainer.Resolve <Interface>(); var childInterface = container.Resolve <Interface>(); parentContainer.Dispose(); Assert.Throws <Exception>(() => container.Resolve <AbstractClass>()); Assert.Throws <Exception>(() => parentContainer.Resolve <Interface>()); var childInterfaceSecond = container.Resolve <Interface>(); Assert.NotNull(abstractClass); Assert.NotNull(parentInterface); Assert.NotNull(childInterface); Assert.NotNull(childInterfaceSecond); Assert.AreEqual(childInterface, childInterfaceSecond); Assert.AreNotEqual(childInterface, parentInterface); }
public void DisposingAContainerRemovesFromTheContext() { var container = new ExtraContainer1(); container.Dispose(); Assert.Throws <Exception>(() => Context.GetContainerByType <ExtraContainer1>()); Assert.Throws <Exception>(() => Context.GetContainerByType(typeof(ExtraContainer1))); }
public void SingletonBindingsTypeWithDefaultConstructorFailIfCircularDependencies() { var container = new ExtraContainer1(); container.Bind <BaseClass, DefaultConstructorCircularDependency>("First").AsSingleton(); container.Bind <BaseClass, DefaultConstructorCircularDependencyOther>("Second").AsSingleton(); ThrowsInnerException <CircularDependencyException>(() => container.Resolve <BaseClass>("First")); }
public void CanChainInheritMultipleContainers() { var parent1Container = new ExtraContainer3(typeof(ExtraContainer1));//"Parent2"); parent1Container.Bind <Interface, ConcreteInterface>().AsSingleton(); parent1Container.Bind <AbstractClass, ConcreteAbstractClass>().AsSingleton(); var parent2Container = new ExtraContainer1(); parent2Container.Bind <Interface, ConcreteInterface>().AsSingleton(); parent2Container.Bind <AbstractClass, ConcreteAbstractClass>().AsSingleton(); parent2Container.Bind <BaseClass, SubClass>().AsSingleton(); var container = new ExtraContainer2(typeof(ExtraContainer3));//"Parent1"); container.Bind <Interface, ConcreteInterface>().AsSingleton(); var baseClass = container.Resolve <BaseClass>(); var parent2BaseClass = parent2Container.Resolve <BaseClass>(); var abstractClass = container.Resolve <AbstractClass>(); var parent1AbstractClass = parent1Container.Resolve <AbstractClass>(); var parent2AbstractClass = parent2Container.Resolve <AbstractClass>(); var parent1Interface = parent1Container.Resolve <Interface>(); var parent2Interface = parent2Container.Resolve <Interface>(); var childInterface = container.Resolve <Interface>(); Assert.NotNull(baseClass); Assert.NotNull(parent2BaseClass); Assert.NotNull(abstractClass); Assert.NotNull(parent1AbstractClass); Assert.NotNull(parent2AbstractClass); Assert.NotNull(parent1Interface); Assert.NotNull(parent2Interface); Assert.NotNull(childInterface); Assert.AreEqual(typeof(SubClass), baseClass.GetType()); Assert.AreEqual(typeof(SubClass), parent2BaseClass.GetType()); Assert.AreEqual(typeof(ConcreteAbstractClass), abstractClass.GetType()); Assert.AreEqual(typeof(ConcreteAbstractClass), parent1AbstractClass.GetType()); Assert.AreEqual(typeof(ConcreteAbstractClass), parent2AbstractClass.GetType()); Assert.AreEqual(typeof(ConcreteInterface), childInterface.GetType()); Assert.AreEqual(typeof(ConcreteInterface), parent1Interface.GetType()); Assert.AreEqual(typeof(ConcreteInterface), parent2Interface.GetType()); Assert.AreEqual(baseClass, parent2BaseClass); Assert.AreEqual(abstractClass, parent1AbstractClass); Assert.AreNotEqual(abstractClass, parent2AbstractClass); Assert.AreNotEqual(parent1AbstractClass, parent2AbstractClass); Assert.AreNotEqual(childInterface, parent1Interface); Assert.AreNotEqual(childInterface, parent2Interface); Assert.AreNotEqual(parent1Interface, parent2Interface); }
public void BindingsOfSameTypeButDifferentCategoriesReturnDifferentObjectsForInstanced() { var container = new ExtraContainer1(); container.Bind <Interface, ConcreteInterface>("Binding1", new ConcreteInterface()); container.Bind <Interface, ConcreteInterface>("Binding2", new ConcreteInterface()); var interface1 = container.Resolve <Interface>("Binding1"); var interface2 = container.Resolve <Interface>("Binding2"); Assert.NotNull(interface1); Assert.NotNull(interface2); Assert.AreNotEqual(interface1, interface2); }
public void BindingsGivenTheSameInstanceResolveToTheSameObject() { var instance = new ConcreteInterface(); var container = new ExtraContainer1(); container.Bind <Interface, ConcreteInterface>("Binding1", instance); container.Bind <Interface, ConcreteInterface>("Binding2", instance); var interface1 = container.Resolve <Interface>("Binding1"); var interface2 = container.Resolve <Interface>("Binding2"); Assert.NotNull(interface1); Assert.NotNull(interface2); Assert.AreEqual(interface1, interface2); }
public void CanResolveTypeWithDefaultConstructorInInheritedClass() { var container = new ExtraContainer1(); container.Bind <BaseClass, SubSubClassWithConstructorDependencies>(); container.Bind <Interface, ConcreteInterface>(); container.Bind <AbstractClass, ConcreteAbstractClass>("First"); var baseClass = container.Resolve <BaseClass>() as SubClassWithConstructorDependencies; Assert.NotNull(baseClass); Assert.NotNull(baseClass.Interface); Assert.NotNull(baseClass.AbstractClass); Assert.AreEqual(typeof(ConcreteInterface), baseClass.Interface.GetType()); Assert.AreEqual(typeof(ConcreteAbstractClass), baseClass.AbstractClass.GetType()); }
public void CanResolveTypeWithSingletonCircleDependencies() { var container = new ExtraContainer1(); container.Bind <Interface, ConcreteInterface>(); container.Bind <AbstractClass, ConcreteAbstractClass>(); container.Bind <BaseClass, SubClassWithFieldDependencies>(); container.Bind <BaseClass, SubClassWithCircularDependencies>("Circle").AsSingleton(); container.Bind <BaseClass, OtherSubClassWithCircularDependencies>("Other").AsSingleton(); container.Bind <Interface, ConcreteInterface>("First"); container.Bind <AbstractClass, ConcreteAbstractClass>("Second"); container.Bind <BaseClass, SubClassWithCategory>("Third"); var instance = container.Resolve <BaseClass>("Circle") as SubClassWithCircularDependencies; Assert.NotNull(instance); var dependencyInterface = instance.Interface; Assert.NotNull(dependencyInterface); Assert.AreEqual(typeof(ConcreteInterface), dependencyInterface.GetType()); var circular = instance.Circular; Assert.NotNull(circular); Assert.AreEqual(typeof(OtherSubClassWithCircularDependencies), circular.GetType()); var otherInterface = ((OtherSubClassWithCircularDependencies)circular).Interface; Assert.NotNull(otherInterface); Assert.AreEqual(typeof(ConcreteInterface), otherInterface.GetType()); var otherCircular = ((OtherSubClassWithCircularDependencies)circular).Circle; Assert.NotNull(otherCircular); Assert.AreEqual(typeof(SubClassWithCircularDependencies), otherCircular.GetType()); Assert.AreEqual(instance, otherCircular); }
public void TwoContainersCannotHaveTheSameType() { var container = new ExtraContainer1(); Assert.Throws <Exception>(() => new ExtraContainer1()); }