public void TestComplexNamedDependency()
{
logger.Trace("Entering TestComplexNamedDependency Test");
var dependencies = new DIConfiguration();
dependencies.Register <TDependency, TComplexNamedImplementation>(true);
dependencies.Register <IAnimal, Dog>(true);
dependencies.Register <IVehicle, Car>(true, ImplementationName.First);
dependencies.Register <IVehicle, Bike>(true, ImplementationName.Second);
var provider = new DIContainer(dependencies);
logger.Trace("Container created");
var complexImplementation = (TComplexNamedImplementation)provider.Resolve <TDependency>();
logger.Trace("Received resolve object");
try
{
Assert.AreEqual(1, complexImplementation.vehicles.Count);
Assert.That(complexImplementation.vehicles[0], Is.InstanceOf <Car>());
Assert.AreEqual(typeof(Dog), complexImplementation.animal.GetType());
}
catch (Exception e)
{
logger.Error(e.Message);
throw;
}
}
public void TestNamedImplementation()
{
logger.Trace("Entering TestNamedImplementation Test");
var dependencies = new DIConfiguration();
dependencies.Register <IVehicle, Car>(true, ImplementationName.First);
dependencies.Register <IVehicle, Bike>(true, ImplementationName.Second);
var provider = new DIContainer(dependencies);
logger.Trace("Container created");
var objCar = provider.Resolve <IVehicle>(ImplementationName.First);
logger.Trace("Received resolve object 1");
var objBike = provider.Resolve <IVehicle>(ImplementationName.Second);
logger.Trace("Received resolve object 2");
try
{
Assert.That(objCar, Is.InstanceOf(typeof(Car)));
Assert.That(objBike, Is.InstanceOf(typeof(Bike)));
}
catch (Exception e)
{
logger.Error(e.Message);
throw;
}
}
public void TestOpenGenericDependencies()
{
logger.Trace("Entering TestOpenGenericDependencies Test");
var dependencies = new DIConfiguration();
dependencies.Register(typeof(IService <>), typeof(ServiceImpl <>));
dependencies.Register <TDependency, TImplementation>(true);
var provider = new DIContainer(dependencies);
logger.Trace("Container created");
var genericObject = (ServiceImpl <TDependency>)provider.Resolve <IService <TDependency> >();
logger.Trace("Received resolve object");
try
{
Assert.AreEqual(genericObject.repository.GetType(), typeof(TImplementation));
}
catch (Exception e)
{
logger.Error(e.Message);
throw;
}
}
public void TestResolvingMultipleImplementations()
{
logger.Trace("Entering TestResolvingMultipleImplementations Test");
var dependencies = new DIConfiguration();
dependencies.Register <IVehicle, Car>(true);
dependencies.Register <IVehicle, Bike>(true);
var provider = new DIContainer(dependencies);
logger.Trace("Container created");
var resolved = provider.Resolve <IEnumerable <IVehicle> >() as List <object>;
logger.Trace("Received resolve object");
try
{
Assert.AreEqual(resolved.Count, 2);
Type[] actual = new Type[] { resolved[0].GetType(), resolved[1].GetType() };
Type[] expected = new Type[] { typeof(Car), typeof(Bike) };
CollectionAssert.AreEquivalent(actual, expected);
}
catch (Exception e)
{
logger.Error(e.Message);
throw;
}
}
public void ResolveGenType()
{
var conf = new DIConfiguration();
conf.Register <IBar, BarFromABar>();
conf.Register(typeof(IGenBar <IBar>), typeof(IGenBar <IBar>));
var container = new DIContainer(conf);
IGenBar <IBar> ogen = container.Resolve <IGenBar <IBar> >();
Assert.IsNotNull(ogen);
}
public void DependencyInjectionThroughConstructor()
{
var conf = new DIConfiguration();
conf.Register <IBar, Bar>();
conf.Register <IFoo, Foo>();
var container = new DIContainer(conf);
var foo = container.Resolve <IFoo>();
Assert.IsNotNull(foo.Bar);
}
public void RegisterClass()
{
DIConfiguration conf = new DIConfiguration();
conf.Register <ABar, BarFromABar>();
conf.Register <IFoo, Foo>();
conf.Register <Foo>();
DIContainer container = new DIContainer(conf);
Foo foo = container.Resolve <Foo>();
Assert.IsNotNull(foo);
}
public void ResolveOpenGenType()
{
DIConfiguration conf = new DIConfiguration();
conf.Register <IBar, BarFromABar>();
conf.Register <IFoo, Foo>();
conf.Register(typeof(IGenFoo <>), typeof(IGenFoo <>));
DIContainer container = new DIContainer(conf);
var genFoo = container.Resolve <IGenFoo <IFoo> >();
Assert.IsNotNull(genFoo);
}
public void CorrectCreateDependency()
{
DIConfiguration conf = new DIConfiguration();
conf.Register <IBar, BarFromIBar>();
conf.Register <ABar, BarFromABar>();
conf.Register <Foo, Foo>();
DIContainer container = new DIContainer(conf);
Foo foo = container.Resolve <Foo>();
Assert.IsNotNull(foo.Bar);
}
public void ResolveEnumerable()
{
var expected = 2;
var conf = new DIConfiguration();
conf.Register <IBar, Bar>();
conf.Register <IBar, AnotherBar>();
var container = new DIContainer(conf);
var bars = container.Resolve <IEnumerable <IBar> >();
Assert.AreEqual(expected, bars.Count());
}
public void ResolveEnumerable()
{
int expected = 2;
DIConfiguration conf = new DIConfiguration();
conf.Register <IBar, BarFromIBar>();
conf.Register <IBar, BarFromABar>();
DIContainer container = new DIContainer(conf);
var bars = container.ResolveAll <IBar>();
Assert.AreEqual(expected, bars.Count());
}
public void RegisterClassAsSelf()
{
var conf = new DIConfiguration();
conf.Register <IBar, Bar>();
conf.Register <IFoo, Foo>();
conf.Register <Service>();
var container = new DIContainer(conf);
var service = container.Resolve <Service>();
Assert.IsNotNull(service);
}
public void ResolveOpenGenericType()
{
var conf = new DIConfiguration();
conf.Register <IBar, Bar>().AsSingleton();
conf.Register <IFoo, Foo>().InstancePerRequest();
conf.Register <IService, Service>();
conf.Register(typeof(IServiceGeneric <>), typeof(ServiceGeneric <>));
var container = new DIContainer(conf);
var serviceGeneric = container.Resolve <IServiceGeneric <IService> >();
Assert.IsNotNull(serviceGeneric.Service);
}
public void WhyThisWork()
{
var conf = new DIConfiguration();
conf.Register <IBar, Bar>().AsSingleton();
conf.Register <IFoo, Foo>().InstancePerRequest();
conf.Register <IService, Service>();
conf.Register(typeof(IServiceGeneric <>), typeof(ServiceGeneric <>));
var container = new DIContainer(conf);
var serviceGeneric = container.Resolve <IServiceGeneric <IService> >();
//При получении конструктора возвращает конструктор класса Service?
var serviceGeneric2 = container.Resolve <IServiceGeneric <ServiceBase> >();
}
public void TestExceptionSituations()
{
logger.Trace("Entering TestExceptionSituations Test");
var dependencies = new DIConfiguration();
try
{
logger.Trace("Trying register dependency");
Assert.Throws <ArgumentException>(delegate { dependencies.Register <TDependency, TDependency>(true); });
}
catch (Exception e)
{
logger.Error(e.Message);
throw;
}
var provider = new DIContainer(dependencies);
logger.Trace("Container created");
try
{
logger.Trace("Trying receive resolve object");
Assert.Throws <KeyNotFoundException> (delegate { var genericObject = (ServiceImpl <TDependency>)provider.Resolve <IService <TDependency> >(); });
}
catch (Exception e)
{
logger.Error(e.Message);
throw;
}
}
public void TestSingletonDependencies()
{
logger.Trace("Entering TestSingletonDependencies Test");
var dependencies = new DIConfiguration();
dependencies.Register <TDependency, TImplementation>(true);
dependencies.Register <IAnimal, Dog>(false);
var provider = new DIContainer(dependencies);
logger.Trace("Container created");
var firstObject = provider.Resolve <TDependency>();
logger.Trace("Received resolve object 1");
var secondObject = provider.Resolve <TDependency>();
logger.Trace("Received resolve object 2");
try
{
Assert.AreSame(firstObject, secondObject);
}
catch (Exception e)
{
logger.Error(e.Message);
throw;
}
var thirdObject = provider.Resolve <IAnimal>();
logger.Trace("Received resolve object 3");
var fourthObject = provider.Resolve <IAnimal>();
logger.Trace("Received resolve object 4");
try
{
Assert.AreNotSame(thirdObject, fourthObject);
}
catch (Exception e)
{
logger.Error(e.Message);
throw;
}
}
public void CyclicDependency()
{
var conf = new DIConfiguration();
conf.Register <IFoo, Foo>();
conf.Register <IBar, CycBar>();
var container = new DIContainer(conf);
try
{
var bar = container.Resolve <IBar>();
Assert.Fail("Cannot be cyclic dependencies");
}
catch (Exception e)
{
Assert.IsTrue(true, e.Message);
}
}
public void InsolvableCreation()
{
DIConfiguration conf = new DIConfiguration();
conf.Register <IFoo, Foo>();
conf.Register <IBar, BarFromIBar>();
DIContainer container = new DIContainer(conf);
try
{
IBar bar = container.Resolve <IBar>();
Assert.Fail("Cannot be created");
}
catch (Exception e)
{
Assert.IsNotNull(e, e.Message);
}
}
public void AbstractClassDependency()
{
var conf = new DIConfiguration();
conf.Register <BarBase, AbstrBar>();
var container = new DIContainer(conf);
var bar = container.Resolve <BarBase>();
Assert.IsNotNull(bar);
}
public void TestDuplicateImplementations()
{
logger.Trace("Entering TestDuplicateImplementations Test");
var dependencies = new DIConfiguration();
dependencies.Register <TDependency, TImplementation>(true);
dependencies.Register <TDependency, TImplementation>(true);
var provider = new DIContainer(dependencies);
logger.Trace("Container created");
try
{
Assert.AreEqual(1, dependencies.dependenciesContainer[typeof(TDependency)].Count);
}
catch (Exception e)
{
logger.Error(e.Message);
throw;
}
}
public void TestRecursiveDependencies()
{
logger.Trace("Entering TestRecursiveDependencies Test");
var dependencies = new DIConfiguration();
dependencies.Register <TDependency, TComplexImplementation>(true);
dependencies.Register <IAnimal, Dog>(true);
dependencies.Register <IVehicle, Car>(true);
dependencies.Register <IVehicle, Bike>(true);
var provider = new DIContainer(dependencies);
logger.Trace("Container created");
var complexImplementation = (TComplexImplementation)provider.Resolve <TDependency>();
logger.Trace("Received resolve object");
try
{
// Check that IEnumerable<IVehicle> dependencies are created.
Type[] actual = new Type[] { complexImplementation.vehicles[0].GetType(), complexImplementation.vehicles[1].GetType() };
Type[] expected = new Type[] { typeof(Car), typeof(Bike) };
CollectionAssert.AreEquivalent(actual, expected);
// Check that IAnimal dependency is created.
Assert.AreEqual(typeof(Dog), complexImplementation.animal.GetType());
}
catch (Exception e)
{
logger.Error(e.Message);
throw;
}
logger.Trace("Testing created Object");
Mock <Dog> dependencyMock = new Mock <Dog>();
dependencyMock.Setup(x => x.DoNothing()).Returns(true);
(complexImplementation as TComplexImplementation).DoNothing(dependencyMock.Object);
}
public void IsSingleton()
{
var conf = new DIConfiguration();
conf.Register <IBar, Bar>().AsSingleton();
var container = new DIContainer(conf);
var bar1 = container.Resolve <IBar>();
var bar2 = container.Resolve <IBar>();
Assert.AreEqual(bar1, bar2);
}
public void IsNotSingleton()
{
DIConfiguration conf = new DIConfiguration();
conf.Register <IBar, BarFromABar>();
DIContainer container = new DIContainer(conf);
IBar bar1 = container.Resolve <IBar>();
IBar bar2 = container.Resolve <IBar>();
Assert.AreNotEqual(bar1, bar2);
}
public void IsNotSingleton()
{
var conf = new DIConfiguration();
conf.Register <IBar, Bar>().InstancePerRequest();
var container = new DIContainer(conf);
var bar1 = container.Resolve <IBar>();
var bar2 = container.Resolve <IBar>();
Assert.AreNotEqual(bar1, bar2);
}
public void AbstractClassAdded()
{
DIConfiguration conf = new DIConfiguration();
try
{
conf.Register <ABar, ABar>();
Assert.Fail("registered class is abstract");
}
catch (Exception e)
{
Assert.IsNotNull(e, e.Message);
}
}
public void RegisterAbstractClassAsSelf()
{
try
{
var conf = new DIConfiguration();
conf.Register <BarBase>();
var container = new DIContainer(conf);
var bar = container.Resolve <BarBase>();
Assert.Fail("Cannot create instance of abstract class");
}
catch (Exception e)
{
Assert.IsTrue(true, e.Message);
}
}
public void RegInterfaceInterface()
{
try
{
var conf = new DIConfiguration();
conf.Register <IBar>();
var container = new DIContainer(conf);
var bar = container.Resolve <IBar>();
Assert.Fail("Cannot create instance of interface");
}
catch (Exception e)
{
Assert.IsNotNull(e, e.Message);
}
}
public void RegisterAbstractClass()
{
try
{
DIConfiguration conf = new DIConfiguration();
conf.Register <ABar>();
DIContainer container = new DIContainer(conf);
ABar bar = container.Resolve <ABar>();
Assert.Fail("Cannot create instance of abstract class");
}
catch (Exception e)
{
Assert.IsNotNull(e, e.Message);
}
}
public void NoSuchType()
{
DIConfiguration conf = new DIConfiguration();
conf.Register <IFoo, Foo>();
DIContainer container = new DIContainer(conf);
try
{
IBar bar = container.Resolve <BarFromIBar>();
Assert.Fail("Cannot create instance of not registered type");
}
catch (Exception e)
{
Assert.IsNotNull(e, e.Message);
}
}
public void NotRegisteredType()
{
var conf = new DIConfiguration();
conf.Register <IFoo, Foo>();
var container = new DIContainer(conf);
try
{
var bar = container.Resolve <IBar>();
Assert.Fail("Cannot create instance of not registered type");
}
catch (Exception e)
{
Assert.IsTrue(true, e.Message);
}
}