public void SetContextOnRegistryTest()
{
var container = new GeckoContainer();
var context = new ShandyGecko.ShandyGeckoDI.Context();
container.RegisterInstance(new TestClass(), context);
Assert.AreEqual(1, context.ContainerRegistries.Count);
}
private void TryGetRootContainer()
{
if (_rootContainer != null)
{
return;
}
_rootContainer = UnityContainerProvider.Instance.RootContainer;
}
public void SetContainer(GeckoContainer geckoContainer)
{
if (_geckoContainer != null)
{
throw new Exception("Container is already set!");
}
_geckoContainer = geckoContainer;
}
public void DefaultConstructorTest()
{
var container = new GeckoContainer();
container.RegisterSingletone <Test1>();
var actual = container.BuildUpType <Test1>();
Assert.IsNotNull(actual);
}
public void SetObjectParameterWithType()
{
var container = new GeckoContainer();
var dummy = new Dummy();
container.RegisterSingletone <Test>().SetParameter(new Parameter(dummy, typeof(IDummy)));
var instance = container.Resolve <Test>();
Assert.AreEqual(dummy, instance.Dummy);
}
public void ContainerRegisterInstanceAsWrongInterfaceTest()
{
var container = new GeckoContainer();
var testClass = new TestClass();
Assert.Throws <ContainerException>(() =>
{
container.RegisterInstance(testClass).As <ITest3>();
});
}
public void SetParameterWithoutNameTest()
{
var container = new GeckoContainer();
container.RegisterSingletone <Test>().SetParameter(new Parameter(Parameter1));
var instance = container.Resolve <Test>("", new Parameter(Parameter2));
Assert.AreEqual(Parameter1, instance.Parameter1);
Assert.AreEqual(Parameter2, instance.Parameter2);
}
public void SetObjectParameterWithoutType()
{
var container = new GeckoContainer();
var dummy = new Dummy();
container.RegisterSingletone <Test>().SetParameter(new Parameter(dummy));
Assert.Throws <ContainerException>(() =>
{
container.Resolve <Test>();
});
}
public void TestInjectInInheritedConstructor()
{
var container = new GeckoContainer();
var test1 = new Test1();
container.RegisterInstance(test1);
var child = container.BuildUpType <ChildTest>();
Assert.IsNotNull(child);
Assert.AreEqual(test1, child.Test1);
}
public void MethodInjectionTest()
{
var container = new GeckoContainer();
var injection1 = new Test1();
container.RegisterInstance(injection1);
var actual = container.BuildUpType <Test2>();
Assert.IsNotNull(actual);
Assert.AreEqual(injection1, actual.Test1);
}
public void TestResolveProtectedDependency()
{
var container = new GeckoContainer();
var test1 = new Test1();
container.RegisterInstance(test1);
var test2 = new TestProtectedDep();
container.BuildUp(test2);
Assert.AreEqual(test1, test2.GetTestDep());
}
public void ParameterBuildUpTest()
{
var container = new GeckoContainer();
var test2 = new Test2();
var test1_1 = new Test1();
var test1_2 = new Test1();
container.BuildUp(test2, new Parameter(test1_1, "1"), new Parameter(test1_2, "2"));
Assert.AreEqual(test1_1, test2.Test1_1);
Assert.AreEqual(test1_2, test2.Test1_2);
}
public void TestResolveInternalDependency()
{
var container = new GeckoContainer();
var test1 = new Test1();
container.RegisterInstance(test1);
var test2 = new TestInternalDep();
container.BuildUp(test2);
Assert.AreEqual(test1, test2.Test1);
}
public void TestResolveInheritedDependency()
{
var container = new GeckoContainer();
var test = new Test();
container.RegisterInstance(test);
var testChild = new TestChild();
container.BuildUp(testChild);
Assert.AreEqual(test, testChild.TestDep);
}
public void ContainerRegisterInstanceTest()
{
var container = new GeckoContainer();
var testClass = new TestClass();
container.RegisterInstance(testClass);
Assert.IsTrue(container.IsKeyRegistered <TestClass>());
var actual = container.Resolve <TestClass>();
Assert.AreEqual(testClass, actual);
}
public void ConstructorWithDependencyAttributeInjectionTest()
{
var container = new GeckoContainer();
var injection = new Test1();
container.RegisterInstance(injection);
container.RegisterSingletone <Test2>();
var actual = container.BuildUpType <Test3>();
Assert.IsNotNull(actual);
Assert.AreEqual(injection, actual.Test1);
Assert.IsNotNull(actual.Test2);
}
public void ContainerRegisterInstanceAsMultipleInterfacesTest()
{
var container = new GeckoContainer();
var testClass = new TestClass();
container.RegisterInstance(testClass).As <ITest>().As <ITest2>();
Assert.IsTrue(container.IsKeyRegistered <TestClass>());
Assert.IsTrue(container.IsKeyRegistered <ITest>());
Assert.IsTrue(container.IsKeyRegistered <ITest2>());
var actual = container.Resolve <ITest2>();
Assert.AreEqual(testClass, actual);
}
public void ConstructorInjectionTest()
{
var container = new GeckoContainer();
var injection0 = new Test1();
var injection1 = new Test1();
container.RegisterInstance(injection0).WithName("Test0");
container.RegisterInstance(injection1).WithName("Test1");
var actual = container.BuildUpType <Test2>();
Assert.IsNotNull(actual);
Assert.AreEqual(injection0, actual.Test0);
Assert.AreEqual(injection1, actual.Test1);
}
public void ConstructorParameterOverProviderInjection()
{
var container = new GeckoContainer();
var test1Param = new Test1();
var test1Provider = new Test1();
container.RegisterInstance(test1Provider);
var test2 = container.BuildUpType <Test2>(new Parameter(test1Param));
Assert.NotNull(test2);
Assert.AreEqual(test1Param, test2.Test1);
Assert.AreNotEqual(test1Provider, test2.Test1);
}
public void ParameterMethodInjectionTest()
{
var container = new GeckoContainer();
var param1 = new Test1();
var param2 = new Test1();
var actual = container.BuildUpType <Test2>(
new Parameter(param1, "TestParam1"),
new Parameter(param2, "TestParam2"));
Assert.IsNotNull(actual);
Assert.AreEqual(param1, actual.TestParam1);
Assert.AreEqual(param2, actual.TestParam2);
Assert.AreNotEqual(actual.TestParam1, actual.TestParam2);
}
public void TestResolveNamedDependency()
{
var container = new GeckoContainer();
var test1 = new Test1();
var test2 = new Test1();
container.RegisterInstance(test1).WithName("Test1");
container.RegisterInstance(test2).WithName("test1");
var testNamedDep = new TestNamedDep();
container.BuildUp(testNamedDep);
Assert.AreEqual(test1, testNamedDep.Test1);
Assert.AreEqual(test2, testNamedDep.Test2);
}
public void ContainerRegisterInstanceWithNameAsInterfaceTest()
{
var container = new GeckoContainer();
var testClass = new TestClass();
container.RegisterInstance(testClass).WithName(TestName).As <ITest>();
Assert.IsFalse(container.IsKeyRegistered <TestClass>());
Assert.IsTrue(container.IsKeyRegistered <TestClass>(TestName));
Assert.IsFalse(container.IsKeyRegistered <ITest>());
Assert.IsTrue(container.IsKeyRegistered <ITest>(TestName));
var actual = container.Resolve <ITest>(TestName);
Assert.AreEqual(testClass, actual);
}
public void ObjectsResolveTest()
{
var dummy = new Dummy();
var container = new GeckoContainer();
container.RegisterInstance(dummy);
container.RegisterSingletone <Test1>();
container.RegisterSingletone <Test2>();
var test2Instance = container.Resolve <Test2>();
Assert.NotNull(test2Instance);
Assert.NotNull(test2Instance.Test1);
Assert.NotNull(test2Instance.Test1.Dummy);
Assert.AreEqual(dummy, test2Instance.Test1.Dummy);
}
protected abstract void RegisterTypes(GeckoContainer container, Context context);
public static ContainerRegistry RegisterSingletone <T>(this GeckoContainer geckoContainer, BaseContext context = null)
{
return(geckoContainer.RegisterProvider <T>(new SingletonProvider <T>(), context));
}
public static ContainerRegistry RegisterInstance <T>(this GeckoContainer geckoContainer, T obj, BaseContext context = null)
{
return(geckoContainer.RegisterProvider <T>(new InstanceProvider <T>(obj), context));
}
public static ContainerRegistry RegisterType <T>(this GeckoContainer geckoContainer, BaseContext context = null)
{
return(geckoContainer.RegisterProvider <T>(new FactoryMethodProvider <T>(), context));
}
