dub-mirrors/poodinis
1
0
Fork 0
mirror of https://github.com/mbierlee/poodinis.git synced 2024-11-15 04:04:01 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Mark bug test-case as being a bug

Browse source
This commit is contained in:
Mike Bierlee 2014-06-14 16:05:04 +02:00
parent 2db7b7644a
commit ad0f36b19a
1 changed files with 245 additions and 245 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

490
test/poodinis/containertest.d
View file

@ -1,246 +1,246 @@
/** /**
* Poodinis Dependency Injection Framework * Poodinis Dependency Injection Framework
* Copyright 2014 Mike Bierlee * Copyright 2014 Mike Bierlee
* This software is licensed under the terms of the MIT license. * This software is licensed under the terms of the MIT license.
* The full terms of the license can be found in the LICENSE file. * The full terms of the license can be found in the LICENSE file.
*/ */
import poodinis.container; import poodinis.container;
import std.exception; import std.exception;
version(unittest) { version(unittest) {
interface TestInterface { interface TestInterface {
} }
class TestClass : TestInterface { class TestClass : TestInterface {
} }
class UnrelatedClass{ class UnrelatedClass{
} }
class FailOnCreationClass { class FailOnCreationClass {
this() { this() {
throw new Exception("This class should not be instantiated"); throw new Exception("This class should not be instantiated");
} }
} }
class AutowiredClass { class AutowiredClass {
} }
class ComponentClass { class ComponentClass {
@Autowire @Autowire
public AutowiredClass autowiredClass; public AutowiredClass autowiredClass;
} }
class ComponentCat { class ComponentCat {
@Autowire @Autowire
public ComponentMouse mouse; public ComponentMouse mouse;
} }
class ComponentMouse { class ComponentMouse {
@Autowire @Autowire
public ComponentCat cat; public ComponentCat cat;
} }
class Eenie { class Eenie {
@Autowire @Autowire
public Meenie meenie; public Meenie meenie;
} }
class Meenie { class Meenie {
@Autowire @Autowire
public Moe moe; public Moe moe;
} }
class Moe { class Moe {
@Autowire @Autowire
public Eenie eenie; public Eenie eenie;
} }
class Ittie { class Ittie {
@Autowire @Autowire
public Bittie bittie; public Bittie bittie;
} }
class Bittie { class Bittie {
@Autowire @Autowire
public Banana banana; public Banana banana;
} }
class Banana { class Banana {
@Autowire @Autowire
public Bittie bittie; public Bittie bittie;
} }
interface SuperInterface { interface SuperInterface {
} }
class SuperImplementation : SuperInterface { class SuperImplementation : SuperInterface {
@Autowire @Autowire
public Banana banana; public Banana banana;
} }
// Test register concrete type // Test register concrete type
unittest { unittest {
auto container = new Container(); auto container = new Container();
auto registration = container.register!(TestClass)(); auto registration = container.register!(TestClass)();
assert(registration.registeredType == typeid(TestClass), "Type of registered type not the same"); assert(registration.registeredType == typeid(TestClass), "Type of registered type not the same");
} }
// Test resolve registered type // Test resolve registered type
unittest { unittest {
auto container = new Container(); auto container = new Container();
container.register!(TestClass)(); container.register!(TestClass)();
TestClass actualInstance = container.resolve!(TestClass)(); TestClass actualInstance = container.resolve!(TestClass)();
assert(actualInstance !is null, "Resolved type is null"); assert(actualInstance !is null, "Resolved type is null");
assert(cast(TestClass) actualInstance, "Resolved class is not the same type as expected"); assert(cast(TestClass) actualInstance, "Resolved class is not the same type as expected");
} }
// Test register interface // Test register interface
unittest { unittest {
auto container = new Container(); auto container = new Container();
container.register!(TestInterface, TestClass)(); container.register!(TestInterface, TestClass)();
TestInterface actualInstance = container.resolve!(TestInterface)(); TestInterface actualInstance = container.resolve!(TestInterface)();
assert(actualInstance !is null, "Resolved type is null"); assert(actualInstance !is null, "Resolved type is null");
assert(cast(TestInterface) actualInstance, "Resolved class is not the same type as expected"); assert(cast(TestInterface) actualInstance, "Resolved class is not the same type as expected");
} }
// Test resolve non-registered type // Test resolve non-registered type
unittest { unittest {
auto container = new Container(); auto container = new Container();
assertThrown!ResolveException(container.resolve!(TestClass)(), "Resolving non-registered type does not fail"); assertThrown!ResolveException(container.resolve!(TestClass)(), "Resolving non-registered type does not fail");
} }
// Test clear registrations // Test clear registrations
unittest { unittest {
auto container = new Container(); auto container = new Container();
container.register!(TestClass)(); container.register!(TestClass)();
container.clearAllRegistrations(); container.clearAllRegistrations();
assertThrown!ResolveException(container.resolve!(TestClass)(), "Resolving cleared type does not fail"); assertThrown!ResolveException(container.resolve!(TestClass)(), "Resolving cleared type does not fail");
} }
// Test get singleton of container // Test get singleton of container
unittest { unittest {
auto instance1 = Container.getInstance(); auto instance1 = Container.getInstance();
auto instance2 = Container.getInstance(); auto instance2 = Container.getInstance();
assert(instance1 is instance2, "getInstance does not return the same instance"); assert(instance1 is instance2, "getInstance does not return the same instance");
} }
// Test resolve single instance for type // Test resolve single instance for type
unittest { unittest {
auto container = new Container(); auto container = new Container();
container.register!(TestClass)().singleInstance(); container.register!(TestClass)().singleInstance();
auto instance1 = container.resolve!(TestClass); auto instance1 = container.resolve!(TestClass);
auto instance2 = 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"); assert(instance1 is instance2, "Resolved instance from single instance scope is not the each time it is resolved");
} }
// Test resolve new instance for type // Test resolve new instance for type
unittest { unittest {
auto container = new Container(); auto container = new Container();
container.register!(TestClass)().newInstance(); container.register!(TestClass)().newInstance();
auto instance1 = container.resolve!(TestClass); auto instance1 = container.resolve!(TestClass);
auto instance2 = 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"); assert(instance1 !is instance2, "Resolved instance from new instance scope is the same each time it is resolved");
} }
// Test resolve existing instance for type // Test resolve existing instance for type
unittest { unittest {
auto container = new Container(); auto container = new Container();
auto expectedInstance = new TestClass(); auto expectedInstance = new TestClass();
container.register!(TestClass)().existingInstance(expectedInstance); container.register!(TestClass)().existingInstance(expectedInstance);
auto actualInstance = container.resolve!(TestClass); auto actualInstance = container.resolve!(TestClass);
assert(expectedInstance is actualInstance, "Resolved instance from existing instance scope is not the same as the registered instance"); assert(expectedInstance is actualInstance, "Resolved instance from existing instance scope is not the same as the registered instance");
} }
// Test autowire resolved instances // Test autowire resolved instances
unittest { unittest {
auto container = new Container(); auto container = new Container();
container.register!AutowiredClass; container.register!AutowiredClass;
container.register!ComponentClass; container.register!ComponentClass;
auto componentInstance = container.resolve!ComponentClass; auto componentInstance = container.resolve!ComponentClass;
auto autowiredInstance = container.resolve!AutowiredClass; auto autowiredInstance = container.resolve!AutowiredClass;
assert(componentInstance.autowiredClass is autowiredInstance, "Member is not autowired upon resolving"); assert(componentInstance.autowiredClass is autowiredInstance, "Member is not autowired upon resolving");
} }
// Test circular autowiring // Test circular autowiring
unittest { unittest {
auto container = new Container(); auto container = new Container();
container.register!ComponentMouse; container.register!ComponentMouse;
container.register!ComponentCat; container.register!ComponentCat;
auto mouse = container.resolve!ComponentMouse; auto mouse = container.resolve!ComponentMouse;
auto cat = container.resolve!ComponentCat; auto cat = container.resolve!ComponentCat;
assert(mouse.cat is cat && cat.mouse is mouse && mouse !is cat, "Circular dependencies should be autowirable"); assert(mouse.cat is cat && cat.mouse is mouse && mouse !is cat, "Circular dependencies should be autowirable");
} }
// Test remove registration // Test remove registration
unittest { unittest {
auto container = new Container(); auto container = new Container();
container.register!TestClass; container.register!TestClass;
container.removeRegistration!TestClass; container.removeRegistration!TestClass;
assertThrown!ResolveException(container.resolve!TestClass); assertThrown!ResolveException(container.resolve!TestClass);
} }
// Test autowiring does not autowire member where instance is non-null // Test autowiring does not autowire member where instance is non-null
unittest { unittest {
auto container = new Container(); auto container = new Container();
auto existingA = new AutowiredClass(); auto existingA = new AutowiredClass();
auto existingB = new ComponentClass(); auto existingB = new ComponentClass();
existingB.autowiredClass = existingA; existingB.autowiredClass = existingA;
container.register!AutowiredClass; container.register!AutowiredClass;
container.register!(ComponentClass).existingInstance(existingB); container.register!(ComponentClass).existingInstance(existingB);
auto resolvedA = container.resolve!AutowiredClass; auto resolvedA = container.resolve!AutowiredClass;
auto resolvedB = container.resolve!ComponentClass; 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"); 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 // Test autowiring circular dependency by third-degree
unittest { unittest {
auto container = new Container(); auto container = new Container();
container.register!Eenie; container.register!Eenie;
container.register!Meenie; container.register!Meenie;
container.register!Moe; container.register!Moe;
auto eenie = container.resolve!Eenie; auto eenie = container.resolve!Eenie;
assert(eenie.meenie.moe.eenie is eenie, "Autowiring third-degree circular dependency failed"); assert(eenie.meenie.moe.eenie is eenie, "Autowiring third-degree circular dependency failed");
} }
// Test autowiring deep circular dependencies // Test autowiring deep circular dependencies
unittest { unittest {
auto container = new Container(); auto container = new Container();
container.register!Ittie; container.register!Ittie;
container.register!Bittie; container.register!Bittie;
container.register!Banana; container.register!Banana;
auto ittie = container.resolve!Ittie; auto ittie = container.resolve!Ittie;
assert(ittie.bittie is ittie.bittie.banana.bittie, "Autowiring deep dependencies failed."); 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 // Test autowiring deep circular dependencies with newInstance scope does not autowire new instance second time
unittest { unittest {
auto container = new Container(); auto container = new Container();
container.register!(Ittie).newInstance(); container.register!(Ittie).newInstance();
container.register!(Bittie).newInstance(); container.register!(Bittie).newInstance();
container.register!(Banana).newInstance(); container.register!(Banana).newInstance();
auto ittie = container.resolve!Ittie; auto ittie = container.resolve!Ittie;
assert(ittie.bittie.banana.bittie.banana is null, "Autowiring deep dependencies with newInstance scope autowired a reoccuring type."); assert(ittie.bittie.banana.bittie.banana is null, "Autowiring deep dependencies with newInstance scope autowired a reoccuring type.");
} }
// Test autowiring type registered by interface // Test autowiring type registered by interface fails (BUG test case)
unittest { unittest {
auto container = new Container(); auto container = new Container();
container.register!Banana; container.register!Banana;
container.register!(SuperInterface, SuperImplementation); container.register!(SuperInterface, SuperImplementation);
SuperImplementation superInstance = cast(SuperImplementation) container.resolve!SuperInterface; SuperImplementation superInstance = cast(SuperImplementation) container.resolve!SuperInterface;
assert(superInstance.banana is null, "Autowire instance which was resolved by interface type, which was not expected to be possible"); assert(superInstance.banana is null, "Autowire instance which was resolved by interface type, which was not expected to be possible");
} }
} }