mirror of
https://github.com/mbierlee/poodinis.git
synced 2024-11-15 04:04:01 +01:00
Synchronize DependencyContainer
The implication is that dependency containers are now always shared data. In the sense of application context, this is acceptable.
This commit is contained in:
Mike Bierlee
parent
8d268846ed
commit
9860624148
|
|
@ -79,7 +79,7 @@ private void printDebugAutowiredInstance(TypeInfo instanceType, void* instanceAd
|
|||
*
|
||||
* See_Also: Autowire
|
||||
*/
|
||||
public void autowire(Type)(DependencyContainer container, Type instance) {
|
||||
public void autowire(Type)(shared(DependencyContainer) container, Type instance) {
|
||||
debug(poodinisVerbose) {
|
||||
printDebugAutowiredInstance(typeid(Type), &instance);
|
||||
}
|
||||
|
|
@ -93,7 +93,7 @@ private void printDebugAutowiringCandidate(TypeInfo candidateInstanceType, void*
|
|||
writeln(format("DEBUG: Autowired instance [%s@%s] to [%s@%s].%s", candidateInstanceType, candidateInstanceAddress, instanceType, instanceAddress, member));
|
||||
}
|
||||
|
||||
private void autowireMember(string member, Type)(DependencyContainer container, Type instance) {
|
||||
private void autowireMember(string member, Type)(shared(DependencyContainer) container, Type instance) {
|
||||
static if(__traits(compiles, __traits(getMember, instance, member)) && __traits(compiles, __traits(getAttributes, __traits(getMember, instance, member)))) {
|
||||
foreach(autowireAttribute; __traits(getAttributes, __traits(getMember, instance, member))) {
|
||||
static if (__traits(isSame, autowireAttribute, Autowire) || is(autowireAttribute == Autowire!T, T)) {
|
||||
|
|
@ -138,9 +138,9 @@ public void globalAutowire(Type)(Type instance) {
|
|||
}
|
||||
|
||||
class AutowiredRegistration(RegistrationType : Object) : Registration {
|
||||
private DependencyContainer container;
|
||||
private shared(DependencyContainer) container;
|
||||
|
||||
public this(TypeInfo registeredType, DependencyContainer container) {
|
||||
public this(TypeInfo registeredType, shared(DependencyContainer) container) {
|
||||
enforce(!(container is null), "Argument 'container' is null. Autowired registrations need to autowire using a container.");
|
||||
this.container = container;
|
||||
super(registeredType, typeid(RegistrationType));
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ class ResolveException : Exception {
|
|||
* In most cases you want to use a global singleton dependency container provided by getInstance() to manage all dependencies.
|
||||
* You can still create new instances of this class for exceptional situations.
|
||||
*/
|
||||
class DependencyContainer {
|
||||
synchronized class DependencyContainer {
|
||||
private Registration[][TypeInfo] registrations;
|
||||
|
||||
private Registration[] autowireStack;
|
||||
|
|
@ -111,16 +111,16 @@ class DependencyContainer {
|
|||
return existingRegistration;
|
||||
}
|
||||
|
||||
AutowiredRegistration!ConcreteType newRegistration = new AutowiredRegistration!ConcreteType(registeredType, this);
|
||||
auto newRegistration = new AutowiredRegistration!ConcreteType(registeredType, this);
|
||||
newRegistration.singleInstance();
|
||||
registrations[registeredType] ~= newRegistration;
|
||||
registrations[registeredType] ~= cast(shared(Registration)) newRegistration;
|
||||
return newRegistration;
|
||||
}
|
||||
|
||||
private Registration getExistingRegistration(TypeInfo registrationType, TypeInfo qualifierType) {
|
||||
auto existingCandidates = registrationType in registrations;
|
||||
if (existingCandidates) {
|
||||
return getRegistration(*existingCandidates, qualifierType);
|
||||
return getRegistration(cast(Registration[]) *existingCandidates, qualifierType);
|
||||
}
|
||||
|
||||
return null;
|
||||
|
|
@ -218,13 +218,13 @@ class DependencyContainer {
|
|||
throw new ResolveException("Type not registered.", resolveType);
|
||||
}
|
||||
|
||||
Registration registration = getQualifiedRegistration(resolveType, qualifierType, *candidates);
|
||||
Registration registration = getQualifiedRegistration(resolveType, qualifierType, cast(Registration[]) *candidates);
|
||||
QualifierType instance;
|
||||
|
||||
if (!autowireStack.canFind(registration)) {
|
||||
autowireStack ~= registration;
|
||||
if (!(cast(Registration[]) autowireStack).canFind(registration)) {
|
||||
autowireStack ~= cast(shared(Registration)) registration;
|
||||
instance = cast(QualifierType) registration.getInstance(new AutowireInstantiationContext());
|
||||
autowireStack.popBack();
|
||||
autowireStack = autowireStack[0 .. $-1];
|
||||
} else {
|
||||
auto autowireContext = new AutowireInstantiationContext();
|
||||
autowireContext.autowireInstance = false;
|
||||
|
|
|
|||
|
|
@ -1,164 +1,164 @@
|
|||
/**
|
||||
* Poodinis Dependency Injection Framework
|
||||
* Copyright 2014-2015 Mike Bierlee
|
||||
* This software is licensed under the terms of the MIT license.
|
||||
* The full terms of the license can be found in the LICENSE file.
|
||||
*/
|
||||
|
||||
import poodinis.autowire;
|
||||
|
||||
import std.exception;
|
||||
|
||||
version(unittest) {
|
||||
class ComponentA {}
|
||||
|
||||
class ComponentB {
|
||||
public @Autowire ComponentA componentA;
|
||||
|
||||
public bool componentIsNull() {
|
||||
return componentA is null;
|
||||
}
|
||||
}
|
||||
|
||||
interface InterfaceA {}
|
||||
|
||||
class ComponentC : InterfaceA {}
|
||||
|
||||
class ComponentD {
|
||||
public @Autowire InterfaceA componentC = null;
|
||||
|
||||
public bool componentIsNull() {
|
||||
return componentC is null;
|
||||
}
|
||||
}
|
||||
|
||||
class DummyAttribute{};
|
||||
|
||||
class ComponentE {
|
||||
@DummyAttribute
|
||||
public ComponentC componentC;
|
||||
}
|
||||
|
||||
class ComponentDeclarationCocktail {
|
||||
alias noomer = int;
|
||||
|
||||
@Autowire
|
||||
public ComponentA componentA;
|
||||
|
||||
public void doesNothing() {
|
||||
}
|
||||
|
||||
~this(){
|
||||
}
|
||||
}
|
||||
|
||||
class ComponentX : InterfaceA {}
|
||||
|
||||
class MonkeyShine {
|
||||
@Autowire!ComponentX
|
||||
public InterfaceA component;
|
||||
}
|
||||
|
||||
class BootstrapBootstrap {
|
||||
@Autowire!ComponentX
|
||||
public InterfaceA componentX;
|
||||
|
||||
@Autowire!ComponentC
|
||||
public InterfaceA componentC;
|
||||
}
|
||||
|
||||
// Test autowiring concrete type to existing instance
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!ComponentA;
|
||||
auto componentB = new ComponentB();
|
||||
container.autowire!(ComponentB)(componentB);
|
||||
assert(!componentB.componentIsNull(), "Autowirable dependency failed to autowire");
|
||||
}
|
||||
|
||||
// Test autowiring interface type to existing instance
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!(InterfaceA, ComponentC);
|
||||
auto componentD = new ComponentD();
|
||||
container.autowire!(ComponentD)(componentD);
|
||||
assert(!componentD.componentIsNull(), "Autowirable dependency failed to autowire");
|
||||
}
|
||||
|
||||
// Test autowiring will only happen once
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!(InterfaceA, ComponentC).newInstance();
|
||||
auto componentD = new ComponentD();
|
||||
container.autowire!(ComponentD)(componentD);
|
||||
auto expectedComponent = componentD.componentC;
|
||||
container.autowire!(ComponentD)(componentD);
|
||||
auto actualComponent = componentD.componentC;
|
||||
assert(expectedComponent is actualComponent, "Autowiring the second time wired a different instance");
|
||||
}
|
||||
|
||||
// Test autowiring unregistered type
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
auto componentD = new ComponentD();
|
||||
assertThrown!(ResolveException)(container.autowire!(ComponentD)(componentD), "Autowiring unregistered type should throw ResolveException");
|
||||
}
|
||||
|
||||
// Test autowiring member with non-autowire attribute does not autowire
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
auto componentE = new ComponentE();
|
||||
container.autowire!ComponentE(componentE);
|
||||
assert(componentE.componentC is null, "Autowiring should not occur for members with attributes other than @Autowire");
|
||||
}
|
||||
|
||||
// Test autowire class with alias declaration
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!ComponentA;
|
||||
auto componentDeclarationCocktail = new ComponentDeclarationCocktail();
|
||||
|
||||
container.autowire(componentDeclarationCocktail);
|
||||
|
||||
assert(componentDeclarationCocktail.componentA !is null, "Autowiring class with non-assignable declarations failed");
|
||||
}
|
||||
|
||||
// Test autowire class with qualifier
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!(InterfaceA, ComponentC);
|
||||
container.register!(InterfaceA, ComponentX);
|
||||
auto componentX = container.resolve!(InterfaceA, ComponentX);
|
||||
|
||||
auto monkeyShine = new MonkeyShine();
|
||||
container.autowire(monkeyShine);
|
||||
|
||||
assert(monkeyShine.component is componentX, "Autowiring class with qualifier failed");
|
||||
}
|
||||
|
||||
// Test autowire class with multiple qualifiers
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!(InterfaceA, ComponentC);
|
||||
container.register!(InterfaceA, ComponentX);
|
||||
auto componentC = container.resolve!(InterfaceA, ComponentC);
|
||||
auto componentX = container.resolve!(InterfaceA, ComponentX);
|
||||
|
||||
auto bootstrapBootstrap = new BootstrapBootstrap();
|
||||
container.autowire(bootstrapBootstrap);
|
||||
|
||||
assert(bootstrapBootstrap.componentX is componentX, "Autowiring class with multiple qualifiers failed");
|
||||
assert(bootstrapBootstrap.componentC is componentC, "Autowiring class with multiple qualifiers failed");
|
||||
}
|
||||
|
||||
// Test getting instance from autowired registration will autowire instance
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!ComponentA;
|
||||
|
||||
auto registration = new AutowiredRegistration!ComponentB(typeid(ComponentB), container).singleInstance();
|
||||
auto instance = cast(ComponentB) registration.getInstance(new AutowireInstantiationContext());
|
||||
|
||||
assert(!instance.componentIsNull());
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Poodinis Dependency Injection Framework
|
||||
* Copyright 2014-2015 Mike Bierlee
|
||||
* This software is licensed under the terms of the MIT license.
|
||||
* The full terms of the license can be found in the LICENSE file.
|
||||
*/
|
||||
|
||||
import poodinis.autowire;
|
||||
|
||||
import std.exception;
|
||||
|
||||
version(unittest) {
|
||||
class ComponentA {}
|
||||
|
||||
class ComponentB {
|
||||
public @Autowire ComponentA componentA;
|
||||
|
||||
public bool componentIsNull() {
|
||||
return componentA is null;
|
||||
}
|
||||
}
|
||||
|
||||
interface InterfaceA {}
|
||||
|
||||
class ComponentC : InterfaceA {}
|
||||
|
||||
class ComponentD {
|
||||
public @Autowire InterfaceA componentC = null;
|
||||
|
||||
public bool componentIsNull() {
|
||||
return componentC is null;
|
||||
}
|
||||
}
|
||||
|
||||
class DummyAttribute{};
|
||||
|
||||
class ComponentE {
|
||||
@DummyAttribute
|
||||
public ComponentC componentC;
|
||||
}
|
||||
|
||||
class ComponentDeclarationCocktail {
|
||||
alias noomer = int;
|
||||
|
||||
@Autowire
|
||||
public ComponentA componentA;
|
||||
|
||||
public void doesNothing() {
|
||||
}
|
||||
|
||||
~this(){
|
||||
}
|
||||
}
|
||||
|
||||
class ComponentX : InterfaceA {}
|
||||
|
||||
class MonkeyShine {
|
||||
@Autowire!ComponentX
|
||||
public InterfaceA component;
|
||||
}
|
||||
|
||||
class BootstrapBootstrap {
|
||||
@Autowire!ComponentX
|
||||
public InterfaceA componentX;
|
||||
|
||||
@Autowire!ComponentC
|
||||
public InterfaceA componentC;
|
||||
}
|
||||
|
||||
// Test autowiring concrete type to existing instance
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!ComponentA;
|
||||
auto componentB = new ComponentB();
|
||||
container.autowire!(ComponentB)(componentB);
|
||||
assert(!componentB.componentIsNull(), "Autowirable dependency failed to autowire");
|
||||
}
|
||||
|
||||
// Test autowiring interface type to existing instance
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!(InterfaceA, ComponentC);
|
||||
auto componentD = new ComponentD();
|
||||
container.autowire!(ComponentD)(componentD);
|
||||
assert(!componentD.componentIsNull(), "Autowirable dependency failed to autowire");
|
||||
}
|
||||
|
||||
// Test autowiring will only happen once
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!(InterfaceA, ComponentC).newInstance();
|
||||
auto componentD = new ComponentD();
|
||||
container.autowire!(ComponentD)(componentD);
|
||||
auto expectedComponent = componentD.componentC;
|
||||
container.autowire!(ComponentD)(componentD);
|
||||
auto actualComponent = componentD.componentC;
|
||||
assert(expectedComponent is actualComponent, "Autowiring the second time wired a different instance");
|
||||
}
|
||||
|
||||
// Test autowiring unregistered type
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
auto componentD = new ComponentD();
|
||||
assertThrown!(ResolveException)(container.autowire!(ComponentD)(componentD), "Autowiring unregistered type should throw ResolveException");
|
||||
}
|
||||
|
||||
// Test autowiring member with non-autowire attribute does not autowire
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
auto componentE = new ComponentE();
|
||||
container.autowire!ComponentE(componentE);
|
||||
assert(componentE.componentC is null, "Autowiring should not occur for members with attributes other than @Autowire");
|
||||
}
|
||||
|
||||
// Test autowire class with alias declaration
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!ComponentA;
|
||||
auto componentDeclarationCocktail = new ComponentDeclarationCocktail();
|
||||
|
||||
container.autowire(componentDeclarationCocktail);
|
||||
|
||||
assert(componentDeclarationCocktail.componentA !is null, "Autowiring class with non-assignable declarations failed");
|
||||
}
|
||||
|
||||
// Test autowire class with qualifier
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!(InterfaceA, ComponentC);
|
||||
container.register!(InterfaceA, ComponentX);
|
||||
auto componentX = container.resolve!(InterfaceA, ComponentX);
|
||||
|
||||
auto monkeyShine = new MonkeyShine();
|
||||
container.autowire(monkeyShine);
|
||||
|
||||
assert(monkeyShine.component is componentX, "Autowiring class with qualifier failed");
|
||||
}
|
||||
|
||||
// Test autowire class with multiple qualifiers
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!(InterfaceA, ComponentC);
|
||||
container.register!(InterfaceA, ComponentX);
|
||||
auto componentC = container.resolve!(InterfaceA, ComponentC);
|
||||
auto componentX = container.resolve!(InterfaceA, ComponentX);
|
||||
|
||||
auto bootstrapBootstrap = new BootstrapBootstrap();
|
||||
container.autowire(bootstrapBootstrap);
|
||||
|
||||
assert(bootstrapBootstrap.componentX is componentX, "Autowiring class with multiple qualifiers failed");
|
||||
assert(bootstrapBootstrap.componentC is componentC, "Autowiring class with multiple qualifiers failed");
|
||||
}
|
||||
|
||||
// Test getting instance from autowired registration will autowire instance
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!ComponentA;
|
||||
|
||||
auto registration = new AutowiredRegistration!ComponentB(typeid(ComponentB), container).singleInstance();
|
||||
auto instance = cast(ComponentB) registration.getInstance(new AutowireInstantiationContext());
|
||||
|
||||
assert(!instance.componentIsNull());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,372 +1,372 @@
|
|||
/**
|
||||
* Poodinis Dependency Injection Framework
|
||||
* Copyright 2014-2015 Mike Bierlee
|
||||
* This software is licensed under the terms of the MIT license.
|
||||
* The full terms of the license can be found in the LICENSE file.
|
||||
*/
|
||||
|
||||
import poodinis.container;
|
||||
|
||||
import std.exception;
|
||||
|
||||
version(unittest) {
|
||||
interface TestInterface {
|
||||
}
|
||||
|
||||
class TestClass : TestInterface {
|
||||
}
|
||||
|
||||
class UnrelatedClass{
|
||||
}
|
||||
|
||||
class FailOnCreationClass {
|
||||
this() {
|
||||
throw new Exception("This class should not be instantiated");
|
||||
}
|
||||
}
|
||||
|
||||
class AutowiredClass {
|
||||
}
|
||||
|
||||
class ComponentClass {
|
||||
@Autowire
|
||||
public AutowiredClass autowiredClass;
|
||||
}
|
||||
|
||||
class ComponentCat {
|
||||
@Autowire
|
||||
public ComponentMouse mouse;
|
||||
}
|
||||
|
||||
class ComponentMouse {
|
||||
@Autowire
|
||||
public ComponentCat cat;
|
||||
}
|
||||
|
||||
class Eenie {
|
||||
@Autowire
|
||||
public Meenie meenie;
|
||||
}
|
||||
|
||||
class Meenie {
|
||||
@Autowire
|
||||
public Moe moe;
|
||||
}
|
||||
|
||||
class Moe {
|
||||
@Autowire
|
||||
public Eenie eenie;
|
||||
}
|
||||
|
||||
class Ittie {
|
||||
@Autowire
|
||||
public Bittie bittie;
|
||||
}
|
||||
|
||||
class Bittie {
|
||||
@Autowire
|
||||
public Banana banana;
|
||||
}
|
||||
|
||||
class Banana {
|
||||
@Autowire
|
||||
public Bittie bittie;
|
||||
}
|
||||
|
||||
interface SuperInterface {
|
||||
}
|
||||
|
||||
class SuperImplementation : SuperInterface {
|
||||
@Autowire
|
||||
public Banana banana;
|
||||
}
|
||||
|
||||
interface Color {
|
||||
}
|
||||
|
||||
class Blue : Color {
|
||||
}
|
||||
|
||||
class Red : Color {
|
||||
}
|
||||
|
||||
class Spiders {
|
||||
@Autowire
|
||||
public TestInterface testMember;
|
||||
}
|
||||
|
||||
class Recursive {
|
||||
@Autowire
|
||||
public Recursive recursive;
|
||||
}
|
||||
|
||||
// Test register concrete type
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
auto registration = container.register!(TestClass)();
|
||||
assert(registration.registeredType == typeid(TestClass), "Type of registered type not the same");
|
||||
}
|
||||
|
||||
// Test resolve registered type
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!(TestClass)();
|
||||
TestClass actualInstance = container.resolve!(TestClass)();
|
||||
assert(actualInstance !is null, "Resolved type is null");
|
||||
assert(cast(TestClass) actualInstance, "Resolved class is not the same type as expected");
|
||||
}
|
||||
|
||||
// Test register interface
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!(TestInterface, TestClass)();
|
||||
TestInterface actualInstance = container.resolve!(TestInterface)();
|
||||
assert(actualInstance !is null, "Resolved type is null");
|
||||
assert(cast(TestInterface) actualInstance, "Resolved class is not the same type as expected");
|
||||
}
|
||||
|
||||
// Test resolve non-registered type
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
assertThrown!ResolveException(container.resolve!(TestClass)(), "Resolving non-registered type does not fail");
|
||||
}
|
||||
|
||||
// Test clear registrations
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!(TestClass)();
|
||||
container.clearAllRegistrations();
|
||||
assertThrown!ResolveException(container.resolve!(TestClass)(), "Resolving cleared type does not fail");
|
||||
}
|
||||
|
||||
// Test get singleton of container
|
||||
unittest {
|
||||
auto instance1 = DependencyContainer.getInstance();
|
||||
auto instance2 = DependencyContainer.getInstance();
|
||||
assert(instance1 is instance2, "getInstance does not return the same instance");
|
||||
}
|
||||
|
||||
// Test resolve single instance for type
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!(TestClass)().singleInstance();
|
||||
auto instance1 = container.resolve!(TestClass);
|
||||
auto instance2 = container.resolve!(TestClass);
|
||||
assert(instance1 is instance2, "Resolved instance from single instance scope is not the each time it is resolved");
|
||||
}
|
||||
|
||||
// Test resolve new instance for type
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!(TestClass)().newInstance();
|
||||
auto instance1 = container.resolve!(TestClass);
|
||||
auto instance2 = container.resolve!(TestClass);
|
||||
assert(instance1 !is instance2, "Resolved instance from new instance scope is the same each time it is resolved");
|
||||
}
|
||||
|
||||
// Test resolve existing instance for type
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
auto expectedInstance = new TestClass();
|
||||
container.register!(TestClass)().existingInstance(expectedInstance);
|
||||
auto actualInstance = container.resolve!(TestClass);
|
||||
assert(expectedInstance is actualInstance, "Resolved instance from existing instance scope is not the same as the registered instance");
|
||||
}
|
||||
|
||||
// Test autowire resolved instances
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!AutowiredClass;
|
||||
container.register!ComponentClass;
|
||||
auto componentInstance = container.resolve!ComponentClass;
|
||||
auto autowiredInstance = container.resolve!AutowiredClass;
|
||||
assert(componentInstance.autowiredClass is autowiredInstance, "Member is not autowired upon resolving");
|
||||
}
|
||||
|
||||
// Test circular autowiring
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!ComponentMouse;
|
||||
container.register!ComponentCat;
|
||||
auto mouse = container.resolve!ComponentMouse;
|
||||
auto cat = container.resolve!ComponentCat;
|
||||
assert(mouse.cat is cat && cat.mouse is mouse && mouse !is cat, "Circular dependencies should be autowirable");
|
||||
}
|
||||
|
||||
// Test remove registration
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!TestClass;
|
||||
container.removeRegistration!TestClass;
|
||||
assertThrown!ResolveException(container.resolve!TestClass);
|
||||
}
|
||||
|
||||
// Test autowiring does not autowire member where instance is non-null
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
auto existingA = new AutowiredClass();
|
||||
auto existingB = new ComponentClass();
|
||||
existingB.autowiredClass = existingA;
|
||||
|
||||
container.register!AutowiredClass;
|
||||
container.register!(ComponentClass).existingInstance(existingB);
|
||||
auto resolvedA = container.resolve!AutowiredClass;
|
||||
auto resolvedB = container.resolve!ComponentClass;
|
||||
|
||||
assert(resolvedB.autowiredClass is existingA && resolvedA !is existingA, "Autowiring shouldn't rewire member when it is already wired to an instance");
|
||||
}
|
||||
|
||||
// Test autowiring circular dependency by third-degree
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!Eenie;
|
||||
container.register!Meenie;
|
||||
container.register!Moe;
|
||||
|
||||
auto eenie = container.resolve!Eenie;
|
||||
|
||||
assert(eenie.meenie.moe.eenie is eenie, "Autowiring third-degree circular dependency failed");
|
||||
}
|
||||
|
||||
// Test autowiring deep circular dependencies
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!Ittie;
|
||||
container.register!Bittie;
|
||||
container.register!Banana;
|
||||
|
||||
auto ittie = container.resolve!Ittie;
|
||||
|
||||
assert(ittie.bittie is ittie.bittie.banana.bittie, "Autowiring deep dependencies failed.");
|
||||
}
|
||||
|
||||
// Test autowiring deep circular dependencies with newInstance scope does not autowire new instance second time
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!(Ittie).newInstance();
|
||||
container.register!(Bittie).newInstance();
|
||||
container.register!(Banana).newInstance();
|
||||
|
||||
auto ittie = container.resolve!Ittie;
|
||||
|
||||
assert(ittie.bittie.banana.bittie.banana is null, "Autowiring deep dependencies with newInstance scope autowired a reoccuring type.");
|
||||
}
|
||||
|
||||
// Test autowiring type registered by interface
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!Banana;
|
||||
container.register!Bittie;
|
||||
container.register!(SuperInterface, SuperImplementation);
|
||||
|
||||
SuperImplementation superInstance = cast(SuperImplementation) container.resolve!SuperInterface;
|
||||
|
||||
assert(!(superInstance.banana is null), "Instance which was resolved by interface type was not autowired.");
|
||||
}
|
||||
|
||||
// Test reusing a container after clearing all registrations
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!Banana;
|
||||
container.clearAllRegistrations();
|
||||
try {
|
||||
container.resolve!Banana;
|
||||
} catch (ResolveException e) {
|
||||
container.register!Banana;
|
||||
return;
|
||||
}
|
||||
assert(false);
|
||||
}
|
||||
|
||||
// Test register multiple concrete classess to same interface type
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!(Color, Blue);
|
||||
container.register!(Color, Red);
|
||||
}
|
||||
|
||||
// Test removing all registrations for type with multiple registrations.
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!(Color, Blue);
|
||||
container.register!(Color, Red);
|
||||
container.removeRegistration!Color;
|
||||
}
|
||||
|
||||
// Test registering same registration again
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
auto firstRegistration = container.register!(Color, Blue);
|
||||
auto secondRegistration = container.register!(Color, Blue);
|
||||
|
||||
assert(firstRegistration is secondRegistration, "First registration is not the same as the second of equal types");
|
||||
}
|
||||
|
||||
// Test resolve registration with multiple qualifiers
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!(Color, Blue);
|
||||
container.register!(Color, Red);
|
||||
try {
|
||||
container.resolve!Color;
|
||||
} catch (ResolveException e) {
|
||||
return;
|
||||
}
|
||||
assert(false);
|
||||
}
|
||||
|
||||
// Test resolve registration with multiple qualifiers using a qualifier
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!(Color, Blue);
|
||||
container.register!(Color, Red);
|
||||
auto blueInstance = container.resolve!(Color, Blue);
|
||||
auto redInstance = container.resolve!(Color, Red);
|
||||
|
||||
assert(blueInstance !is redInstance, "Resolving type with multiple, different registrations yielded the same instance");
|
||||
assert(blueInstance !is null, "Resolved blue instance to null");
|
||||
assert(redInstance !is null, "Resolved red instance to null");
|
||||
}
|
||||
|
||||
// Test autowire of unqualified member typed by interface.
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!Spiders;
|
||||
container.register!(TestInterface, TestClass);
|
||||
|
||||
auto instance = container.resolve!Spiders;
|
||||
|
||||
assert(!(instance is null), "Container failed to autowire member by interface");
|
||||
}
|
||||
|
||||
// Register existing registration
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
|
||||
auto firstRegistration = container.register!TestClass;
|
||||
auto secondRegistration = container.register!TestClass;
|
||||
|
||||
assert(firstRegistration is secondRegistration, "Registering the same registration twice registers the dependencies twice.");
|
||||
}
|
||||
|
||||
// Register existing registration by supertype
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
|
||||
auto firstRegistration = container.register!(TestInterface, TestClass);
|
||||
auto secondRegistration = container.register!(TestInterface, TestClass);
|
||||
|
||||
assert(firstRegistration is secondRegistration, "Registering the same registration by super type twice registers the dependencies twice.");
|
||||
}
|
||||
|
||||
// Resolve dependency depending on itself
|
||||
unittest {
|
||||
auto container = new DependencyContainer();
|
||||
container.register!Recursive;
|
||||
|
||||
auto instance = container.resolve!Recursive;
|
||||
|
||||
assert(instance.recursive is instance, "Resolving dependency that depends on itself fails.");
|
||||
assert(instance.recursive.recursive is instance, "Resolving dependency that depends on itself fails.");
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Poodinis Dependency Injection Framework
|
||||
* Copyright 2014-2015 Mike Bierlee
|
||||
* This software is licensed under the terms of the MIT license.
|
||||
* The full terms of the license can be found in the LICENSE file.
|
||||
*/
|
||||
|
||||
import poodinis.container;
|
||||
|
||||
import std.exception;
|
||||
|
||||
version(unittest) {
|
||||
interface TestInterface {
|
||||
}
|
||||
|
||||
class TestClass : TestInterface {
|
||||
}
|
||||
|
||||
class UnrelatedClass{
|
||||
}
|
||||
|
||||
class FailOnCreationClass {
|
||||
this() {
|
||||
throw new Exception("This class should not be instantiated");
|
||||
}
|
||||
}
|
||||
|
||||
class AutowiredClass {
|
||||
}
|
||||
|
||||
class ComponentClass {
|
||||
@Autowire
|
||||
public AutowiredClass autowiredClass;
|
||||
}
|
||||
|
||||
class ComponentCat {
|
||||
@Autowire
|
||||
public ComponentMouse mouse;
|
||||
}
|
||||
|
||||
class ComponentMouse {
|
||||
@Autowire
|
||||
public ComponentCat cat;
|
||||
}
|
||||
|
||||
class Eenie {
|
||||
@Autowire
|
||||
public Meenie meenie;
|
||||
}
|
||||
|
||||
class Meenie {
|
||||
@Autowire
|
||||
public Moe moe;
|
||||
}
|
||||
|
||||
class Moe {
|
||||
@Autowire
|
||||
public Eenie eenie;
|
||||
}
|
||||
|
||||
class Ittie {
|
||||
@Autowire
|
||||
public Bittie bittie;
|
||||
}
|
||||
|
||||
class Bittie {
|
||||
@Autowire
|
||||
public Banana banana;
|
||||
}
|
||||
|
||||
class Banana {
|
||||
@Autowire
|
||||
public Bittie bittie;
|
||||
}
|
||||
|
||||
interface SuperInterface {
|
||||
}
|
||||
|
||||
class SuperImplementation : SuperInterface {
|
||||
@Autowire
|
||||
public Banana banana;
|
||||
}
|
||||
|
||||
interface Color {
|
||||
}
|
||||
|
||||
class Blue : Color {
|
||||
}
|
||||
|
||||
class Red : Color {
|
||||
}
|
||||
|
||||
class Spiders {
|
||||
@Autowire
|
||||
public TestInterface testMember;
|
||||
}
|
||||
|
||||
class Recursive {
|
||||
@Autowire
|
||||
public Recursive recursive;
|
||||
}
|
||||
|
||||
// Test register concrete type
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
auto registration = container.register!(TestClass)();
|
||||
assert(registration.registeredType == typeid(TestClass), "Type of registered type not the same");
|
||||
}
|
||||
|
||||
// Test resolve registered type
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!(TestClass)();
|
||||
TestClass actualInstance = container.resolve!(TestClass)();
|
||||
assert(actualInstance !is null, "Resolved type is null");
|
||||
assert(cast(TestClass) actualInstance, "Resolved class is not the same type as expected");
|
||||
}
|
||||
|
||||
// Test register interface
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!(TestInterface, TestClass)();
|
||||
TestInterface actualInstance = container.resolve!(TestInterface)();
|
||||
assert(actualInstance !is null, "Resolved type is null");
|
||||
assert(cast(TestInterface) actualInstance, "Resolved class is not the same type as expected");
|
||||
}
|
||||
|
||||
// Test resolve non-registered type
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
assertThrown!ResolveException(container.resolve!(TestClass)(), "Resolving non-registered type does not fail");
|
||||
}
|
||||
|
||||
// Test clear registrations
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!(TestClass)();
|
||||
container.clearAllRegistrations();
|
||||
assertThrown!ResolveException(container.resolve!(TestClass)(), "Resolving cleared type does not fail");
|
||||
}
|
||||
|
||||
// Test get singleton of container
|
||||
unittest {
|
||||
auto instance1 = DependencyContainer.getInstance();
|
||||
auto instance2 = DependencyContainer.getInstance();
|
||||
assert(instance1 is instance2, "getInstance does not return the same instance");
|
||||
}
|
||||
|
||||
// Test resolve single instance for type
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!(TestClass)().singleInstance();
|
||||
auto instance1 = container.resolve!(TestClass);
|
||||
auto instance2 = container.resolve!(TestClass);
|
||||
assert(instance1 is instance2, "Resolved instance from single instance scope is not the each time it is resolved");
|
||||
}
|
||||
|
||||
// Test resolve new instance for type
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!(TestClass)().newInstance();
|
||||
auto instance1 = container.resolve!(TestClass);
|
||||
auto instance2 = container.resolve!(TestClass);
|
||||
assert(instance1 !is instance2, "Resolved instance from new instance scope is the same each time it is resolved");
|
||||
}
|
||||
|
||||
// Test resolve existing instance for type
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
auto expectedInstance = new TestClass();
|
||||
container.register!(TestClass)().existingInstance(expectedInstance);
|
||||
auto actualInstance = container.resolve!(TestClass);
|
||||
assert(expectedInstance is actualInstance, "Resolved instance from existing instance scope is not the same as the registered instance");
|
||||
}
|
||||
|
||||
// Test autowire resolved instances
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!AutowiredClass;
|
||||
container.register!ComponentClass;
|
||||
auto componentInstance = container.resolve!ComponentClass;
|
||||
auto autowiredInstance = container.resolve!AutowiredClass;
|
||||
assert(componentInstance.autowiredClass is autowiredInstance, "Member is not autowired upon resolving");
|
||||
}
|
||||
|
||||
// Test circular autowiring
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!ComponentMouse;
|
||||
container.register!ComponentCat;
|
||||
auto mouse = container.resolve!ComponentMouse;
|
||||
auto cat = container.resolve!ComponentCat;
|
||||
assert(mouse.cat is cat && cat.mouse is mouse && mouse !is cat, "Circular dependencies should be autowirable");
|
||||
}
|
||||
|
||||
// Test remove registration
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!TestClass;
|
||||
container.removeRegistration!TestClass;
|
||||
assertThrown!ResolveException(container.resolve!TestClass);
|
||||
}
|
||||
|
||||
// Test autowiring does not autowire member where instance is non-null
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
auto existingA = new AutowiredClass();
|
||||
auto existingB = new ComponentClass();
|
||||
existingB.autowiredClass = existingA;
|
||||
|
||||
container.register!AutowiredClass;
|
||||
container.register!(ComponentClass).existingInstance(existingB);
|
||||
auto resolvedA = container.resolve!AutowiredClass;
|
||||
auto resolvedB = container.resolve!ComponentClass;
|
||||
|
||||
assert(resolvedB.autowiredClass is existingA && resolvedA !is existingA, "Autowiring shouldn't rewire member when it is already wired to an instance");
|
||||
}
|
||||
|
||||
// Test autowiring circular dependency by third-degree
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!Eenie;
|
||||
container.register!Meenie;
|
||||
container.register!Moe;
|
||||
|
||||
auto eenie = container.resolve!Eenie;
|
||||
|
||||
assert(eenie.meenie.moe.eenie is eenie, "Autowiring third-degree circular dependency failed");
|
||||
}
|
||||
|
||||
// Test autowiring deep circular dependencies
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!Ittie;
|
||||
container.register!Bittie;
|
||||
container.register!Banana;
|
||||
|
||||
auto ittie = container.resolve!Ittie;
|
||||
|
||||
assert(ittie.bittie is ittie.bittie.banana.bittie, "Autowiring deep dependencies failed.");
|
||||
}
|
||||
|
||||
// Test autowiring deep circular dependencies with newInstance scope does not autowire new instance second time
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!(Ittie).newInstance();
|
||||
container.register!(Bittie).newInstance();
|
||||
container.register!(Banana).newInstance();
|
||||
|
||||
auto ittie = container.resolve!Ittie;
|
||||
|
||||
assert(ittie.bittie.banana.bittie.banana is null, "Autowiring deep dependencies with newInstance scope autowired a reoccuring type.");
|
||||
}
|
||||
|
||||
// Test autowiring type registered by interface
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!Banana;
|
||||
container.register!Bittie;
|
||||
container.register!(SuperInterface, SuperImplementation);
|
||||
|
||||
SuperImplementation superInstance = cast(SuperImplementation) container.resolve!SuperInterface;
|
||||
|
||||
assert(!(superInstance.banana is null), "Instance which was resolved by interface type was not autowired.");
|
||||
}
|
||||
|
||||
// Test reusing a container after clearing all registrations
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!Banana;
|
||||
container.clearAllRegistrations();
|
||||
try {
|
||||
container.resolve!Banana;
|
||||
} catch (ResolveException e) {
|
||||
container.register!Banana;
|
||||
return;
|
||||
}
|
||||
assert(false);
|
||||
}
|
||||
|
||||
// Test register multiple concrete classess to same interface type
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!(Color, Blue);
|
||||
container.register!(Color, Red);
|
||||
}
|
||||
|
||||
// Test removing all registrations for type with multiple registrations.
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!(Color, Blue);
|
||||
container.register!(Color, Red);
|
||||
container.removeRegistration!Color;
|
||||
}
|
||||
|
||||
// Test registering same registration again
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
auto firstRegistration = container.register!(Color, Blue);
|
||||
auto secondRegistration = container.register!(Color, Blue);
|
||||
|
||||
assert(firstRegistration is secondRegistration, "First registration is not the same as the second of equal types");
|
||||
}
|
||||
|
||||
// Test resolve registration with multiple qualifiers
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!(Color, Blue);
|
||||
container.register!(Color, Red);
|
||||
try {
|
||||
container.resolve!Color;
|
||||
} catch (ResolveException e) {
|
||||
return;
|
||||
}
|
||||
assert(false);
|
||||
}
|
||||
|
||||
// Test resolve registration with multiple qualifiers using a qualifier
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!(Color, Blue);
|
||||
container.register!(Color, Red);
|
||||
auto blueInstance = container.resolve!(Color, Blue);
|
||||
auto redInstance = container.resolve!(Color, Red);
|
||||
|
||||
assert(blueInstance !is redInstance, "Resolving type with multiple, different registrations yielded the same instance");
|
||||
assert(blueInstance !is null, "Resolved blue instance to null");
|
||||
assert(redInstance !is null, "Resolved red instance to null");
|
||||
}
|
||||
|
||||
// Test autowire of unqualified member typed by interface.
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!Spiders;
|
||||
container.register!(TestInterface, TestClass);
|
||||
|
||||
auto instance = container.resolve!Spiders;
|
||||
|
||||
assert(!(instance is null), "Container failed to autowire member by interface");
|
||||
}
|
||||
|
||||
// Register existing registration
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
|
||||
auto firstRegistration = container.register!TestClass;
|
||||
auto secondRegistration = container.register!TestClass;
|
||||
|
||||
assert(firstRegistration is secondRegistration, "Registering the same registration twice registers the dependencies twice.");
|
||||
}
|
||||
|
||||
// Register existing registration by supertype
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
|
||||
auto firstRegistration = container.register!(TestInterface, TestClass);
|
||||
auto secondRegistration = container.register!(TestInterface, TestClass);
|
||||
|
||||
assert(firstRegistration is secondRegistration, "Registering the same registration by super type twice registers the dependencies twice.");
|
||||
}
|
||||
|
||||
// Resolve dependency depending on itself
|
||||
unittest {
|
||||
shared(DependencyContainer) container = new DependencyContainer();
|
||||
container.register!Recursive;
|
||||
|
||||
auto instance = container.resolve!Recursive;
|
||||
|
||||
assert(instance.recursive is instance, "Resolving dependency that depends on itself fails.");
|
||||
assert(instance.recursive.recursive is instance, "Resolving dependency that depends on itself fails.");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue