public void Resolve_UsingAutoFactoryOfInterface_ThrowsRegistrationException() {
var container = new NCopContainer(registry => {
registry.Register<IFoo>();
});
var instance = container.Resolve<IFoo>();
}
public void TryResolve_NotRegisteredServiceWithMultipuleArguments_DontThrowsRegistrationExceptionAndReturnsNull()
{
var container = new NCopContainer(registry => { });
var instance = container.TryResolve <string, int, IFoo>("NCop", 9);
Assert.IsNull(instance);
}
public void TryResolve_NotRegisteredService_DontThrowsRegistrationExceptionAndReturnsNull()
{
var container = new NCopContainer(registry => { });
var instance = container.TryResolve <IFoo>();
Assert.IsNull(instance);
}
public void Resolve_UsingAsPerHttpRequestExpressionRegistrationWhenThereIsNoHttpContext_ThrowsLifetimeStragtegyException()
{
var container = new NCopContainer(registry => {
registry.Register <Foo>().AsSingleton().PerHttpRequest();
});
container.Resolve <Foo>();
}
public void Resolve_UsingAutoFactoryOfInterface_ThrowsRegistrationException()
{
var container = new NCopContainer(registry => {
registry.Register <IFoo>();
});
var instance = container.Resolve <IFoo>();
}
public void ResolveOfDependetType_UsingFactoryThatCallsResolveOfDependencyObject_ReturnsTheResolvedInstance() {
var container = new NCopContainer(registry => {
registry.Register<Foo>();
registry.Register<IBar>(r => new Bar(r.Resolve<Foo>()));
});
Assert.IsNotNull(container.Resolve<IBar>());
}
public void Resolve_UsingAutoFactoryOfInterfaceThatBindsToSelf_ThrowsRegistrationException()
{
var container = new NCopContainer(registry => {
registry.Register <IFoo>().ToSelf();
});
container.Resolve <IFoo>();
}
public void Resolve_UsingAutoFactoryAndCastingUsingTheAsExpresion_ReturnsTheResolvedInstance() {
var container = new NCopContainer(registry => {
registry.Register<IFoo>().From<Foo>();
});
var instance = container.Resolve<IFoo>();
Assert.IsNotNull(instance);
}
public void ResolveOfDependetType_UsingFactoryThatCallsResolveOfDependencyObject_ReturnsTheResolvedInstance()
{
var container = new NCopContainer(registry => {
registry.Register <Foo>();
registry.Register <IBar>((r) => new Bar(r.Resolve <Foo>()));
});
Assert.IsNotNull(container.Resolve <IBar>());
}
public void AutoRegister_OfTypeThatHasMoreThanOneConstructorAndWithoutDependencyAttribute_ThrowsRegistrationException()
{
var container = new NCopContainer(registry => {
registry.Register <IFoo>().As <Foo>();
registry.RegisterAuto <AmbiguousConstructor>();
});
var instance = container.Resolve <AmbiguousConstructor>();
}
public void Resolve_UsingFactoryWithTypedArgument_ReturnsTheResolvedInstanceThatHoldsTheResultOfTypedArgument() {
var container = new NCopContainer(registry => {
registry.Register<IFoo, string>((r, name) => new Foo(name));
});
var instance = container.Resolve<string, IFoo>("Test");
Assert.IsNotNull(instance);
Assert.AreEqual(instance.Name, "Test");
}
public void Resolve_UsingAsSingletonExpressionRegistrationWithAutoFactory_ReturnsTheSameObjectForDifferentResolveCalls() {
var container = new NCopContainer(registry => {
registry.Register<Foo>().AsSingleton();
});
var instance = container.Resolve<Foo>();
var instatance2 = container.Resolve<Foo>();
Assert.AreSame(instance, instatance2);
}
public void Resolve_UsingAutoFactoryAndCastingUsingTheAsExpresion_ReturnsTheResolvedInstance()
{
var container = new NCopContainer(registry => {
registry.Register <IFoo>().As <Foo>();
});
var instance = container.Resolve <IFoo>();
Assert.IsNotNull(instance);
}
public void Resolve_UsingAutoFactoryAndCastingWithAsExpressionAndAfterThatUsingTheAsSingletonExpressionRegistration_ReturnsTheSameObjectForDifferentResolveCalls()
{
var container = new NCopContainer(registry => {
registry.Register <IFoo>().As <Foo>().AsSingleton();
});
var instance = container.Resolve <IFoo>();
var instatance2 = container.Resolve <IFoo>();
Assert.AreSame(instance, instatance2);
}
public void Resolve_InChildContainerUsesParentContainer_ReusesParentContainerAndReturnsTheReolvedObject()
{
var container = new NCopContainer(registry => {
registry.Register <Foo>();
});
var childContainer = container.CreateChildContainer(registry => { });
var instance = childContainer.Resolve <Foo>();
Assert.IsNotNull(instance);
}
public void Resolve_UsingAsSingletonExpressionRegistrationWithFactory_ReturnsTheSameObjectForDifferentResolveCalls()
{
var container = new NCopContainer(registry => {
registry.Register <Foo>((reg) => new Foo()).AsSingleton();
});
var instance = container.Resolve <Foo>();
var instatance2 = container.Resolve <Foo>();
Assert.AreSame(instance, instatance2);
}
public void AutoRegister_WithPropertyDependency_ReturnsTheResolvedInstanceFilledWithTheAutoResolvedProperty()
{
var container = new NCopContainer(registry => {
registry.Register <IFoo>().As <Foo>();
registry.RegisterAuto <PropertyDependency>();
});
var instance = container.Resolve <PropertyDependency>();
Assert.IsNotNull(instance.Foo);
}
public void AutoRegister_WithConstructorDependencyThatHasOneDependentArgument_ReturnsTheResolvedInstanceFilledWithTheDependentArgument()
{
var container = new NCopContainer(registry => {
registry.Register <IFoo>().As <Foo>();
registry.RegisterAuto <CtorDependency>();
});
var instance = container.Resolve <CtorDependency>();
Assert.IsNotNull(instance.Foo);
}
public void Resolve_UsingFactoryWithTypedArgument_ReturnsTheResolvedInstanceThatHoldsTheResultOfTypedArgument()
{
var container = new NCopContainer(registry => {
registry.Register <IFoo, string>((r, name) => new Foo(name));
});
var instance = container.Resolve <string, IFoo>("Test");
Assert.IsNotNull(instance);
Assert.AreEqual(instance.Name, "Test");
}
public void Resolve_UsingNamedExpressionOfSpecificTypeAndAutoWithoutNameOfTheSameType_ReturnsDifferentInstancesOfTheSameType() {
var container = new NCopContainer(registry => {
registry.Register<Foo>().Named("NCop");
registry.Register<Foo>();
});
var instance = container.Resolve<Foo>();
var namedInstance = container.ResolveNamed<Foo>("NCop");
Assert.AreNotSame(namedInstance, instance);
}
public void Resolve_UsingAutoFactoryThatBindsToSelf_ReturnsTheResolvedInstance()
{
var container = new NCopContainer(registry => {
registry.Register <Foo>().ToSelf();
});
var instance = container.Resolve <Foo>();
Assert.IsNotNull(instance);
Assert.IsInstanceOfType(instance, typeof(Foo));
}
public void Resolve_UsingNamedExpressionOfSpecificTypeAndAutoWithoutNameOfTheSameType_ReturnsDifferentInstancesOfTheSameType()
{
var container = new NCopContainer(registry => {
registry.Register <Foo>().Named("NCop");
registry.Register <Foo>();
});
var instance = container.Resolve <Foo>();
var namedInstance = container.ResolveNamed <Foo>("NCop");
Assert.AreNotSame(namedInstance, instance);
}
public void AutoRegister_OfTypeThatHasTwoDependentPropertiesThatOneOfThemIsAnnotatedWithIgnoreDependency_ReturnsResolvedInstanceWithOnlyOneDependentProperty()
{
var container = new NCopContainer(registry => {
registry.Register <IFoo>().As <Foo>();
registry.RegisterAuto <IgnoreDependencyClass>();
});
var instance = container.Resolve <IgnoreDependencyClass>();
Assert.IsNotNull(instance.Injected);
Assert.IsNull(instance.Ignored);
}
public void AutoRegister_OfInterfaceAndCastingWithAsExpressionToConcreteTypeThatHasOneDependentProperty_ReturnsResolvedInstanceWithFilledProperty()
{
var container = new NCopContainer(registry => {
registry.Register <Baz>().ToSelf();
registry.RegisterAuto <IFoo>().As <Boo>();
});
var instance = container.Resolve <IFoo>() as Boo;
Assert.IsNotNull(instance);
Assert.IsNotNull(instance.Baz);
}
public void ResolveInChildContainerAndInParentContainer_UsingAutoRegistrationInParentContainerAsSingletonReusedWithinContainer_ReturnsTheSameInstance()
{
var container = new NCopContainer(registry => {
registry.Register <Foo>().AsSingleton().ReusedWithinHierarchy();
});
var childContainer = container.CreateChildContainer(registry => { });
var instance = container.Resolve <Foo>();
var instance2 = childContainer.Resolve <Foo>();
Assert.AreSame(instance, instance2);
}
public void DisposeOfContainer_OfDisposableObjectWhichIsOwnedExternally_ReturnsNotDispsoedIndication()
{
var container = new NCopContainer(registry => {
registry.Register <Foo>().OwnedExternally();
});
var instance = container.Resolve <Foo>();
Assert.IsFalse(instance.IsDisposed);
container.Dispose();
Assert.IsFalse(instance.IsDisposed);
}
public void AutoRegister_OfTypeThatHasMoreThanOneConstructorWithDependencyAttribute_ReturnsResolvedInstanceAndDontThrowsRegistrationException()
{
var container = new NCopContainer(registry => {
registry.Register <IFoo>().As <Foo>();
registry.RegisterAuto <AmbiguousConstructorFixedWithDependencyAttribute>();
});
var instance = container.Resolve <AmbiguousConstructorFixedWithDependencyAttribute>();
Assert.IsNotNull(instance);
Assert.IsNotNull(instance.Foo);
}
public void AutoRegister_OfTypeThatHasTwoPropertiesThatOneOfThemIsDependentAndTheOtherFilledByDependentConstructor_ReturnsResolvedInstanceWithBothPropertiesFilled()
{
var container = new NCopContainer(registry => {
registry.Register <IFoo>().As <Foo>().AsSingleton();
registry.RegisterAuto <Bar>();
});
var instance = container.Resolve <Bar>();
Assert.IsNotNull(instance.ByCtor);
Assert.IsNotNull(instance.ByProperty);
Assert.AreSame(instance.ByCtor, instance.ByProperty);
}
public void Resolve_UsingAsPerHttpRequestExpressionRegistrationWhenUsingTwoDiffrentContext_ReturnsDiffrentInstancesPerHttpContextInstance()
{
Foo foo = null;
var container = new NCopContainer(registry => {
registry.Register <Foo>().AsSingleton().PerHttpRequest();
});
SetHttpContext();
foo = container.Resolve <Foo>();
Assert.AreEqual(foo, container.Resolve <Foo>());
SetHttpContext();
Assert.AreNotEqual(foo, container.Resolve <Foo>());
}
public void DisposeOfParentContainer_OfDisposableObjectWhichIsOwnedByChildContainer_ReturnsDispsoedIndication()
{
var parentContainer = new NCopContainer(registry => {
});
var childContainer = parentContainer.CreateChildContainer(registry => {
registry.Register <Foo>();
});
var instance = childContainer.Resolve <Foo>();
Assert.IsFalse(instance.IsDisposed);
parentContainer.Dispose();
Assert.IsFalse(instance.IsDisposed);
}
public void DisposeOfContainer_OfDisposableNamedObjectWithAnArgumentWhichIsOwnedExternally_ReturnsTheNamedInstanceWithNotDispsoedIndication()
{
var container = new NCopContainer(registry => {
registry.Register <IFoo, string>((c, name) => new Foo(name))
.Named("NCop")
.OwnedExternally();
});
var instance = container.TryResolve <string, IFoo>("NCop", "NCop") as Foo;
container.Dispose();
Assert.IsNotNull(instance);
Assert.IsTrue(instance.Name.Equals("NCop"));
Assert.IsFalse(instance.IsDisposed);
}
public async Task Resolve_UsingAsPerThreadSingletonExpressionRegistrationWithAutoFactory_ReturnsDiffrentOjectsForDiffrentThreadsAndTheSameObjectForDifferentResolveCallsOnTheSameThread()
{
Foo foo1 = null;
Foo foo2 = null;
var container = new NCopContainer(registry => {
registry.Register <Foo>().AsSingleton().PerThread();
});
foo1 = await Task.Factory.StartNew(() => container.Resolve <Foo>());
foo2 = await Task.Factory.StartNew(() => container.Resolve <Foo>());
Assert.AreNotEqual(foo1, foo2);
Assert.AreEqual(container.Resolve <Foo>(), container.Resolve <Foo>());
}
public async Task Resolve_UsingAsPerHybridRequestExpressionRegistrationWhenHttpContextIsNotAvailable_ReturnsTheSameInstancePerThreadRequest()
{
Foo foo = null;
Foo foo2 = null;
NCopContainer container = null;
container = new NCopContainer(registry => {
registry.Register <Foo>().AsSingleton().PerHybridRequest();
});
foo = container.Resolve <Foo>();
Assert.AreEqual(foo, container.Resolve <Foo>());
foo2 = await Task.Factory.StartNew(() => container.Resolve <Foo>());
Assert.AreEqual(foo, foo2);
}
public void DisposeOfContainer_OfDisposableNamedObjectWithAnArgumentWhichIsOwnedExternally_ReturnsTheNamedInstanceWithNotDispsoedIndication() {
var container = new NCopContainer(registry => {
registry.Register<IFoo, string>((c, name) => new Foo(name))
.Named("NCop")
.OwnedExternally();
});
var instance = container.TryResolve<string, IFoo>("NCop", "NCop") as Foo;
container.Dispose();
Assert.IsNotNull(instance);
Assert.IsTrue(instance.Name.Equals("NCop"));
Assert.IsFalse(instance.IsDisposed);
}
public void Resolve_UsingAsPerHttpRequestExpressionRegistrationWhenThereIsNoHttpContext_ThrowsLifetimeStragtegyException() {
var container = new NCopContainer(registry => {
registry.Register<Foo>().AsSingleton().PerHttpRequest();
});
container.Resolve<Foo>();
}
public void TryResolve_NotRegisteredServiceWithMultipuleArguments_DontThrowsRegistrationExceptionAndReturnsNull() {
var container = new NCopContainer(registry => { });
var instance = container.TryResolve<string, int, IFoo>("NCop", 9);
Assert.IsNull(instance);
}
public void Resolve_UsingAsPerHybridRequestExpressionRegistrationWhenHttpContextIsAvailable_ReturnsDiffrentInstancesPerHttpContextInstance() {
Foo foo = null;
NCopContainer container = null;
SetHttpContext();
container = new NCopContainer(registry => {
registry.Register<Foo>().AsSingleton().PerHybridRequest();
});
foo = container.Resolve<Foo>();
Assert.AreEqual(foo, container.Resolve<Foo>());
SetHttpContext();
Assert.AreNotEqual(foo, container.Resolve<Foo>());
}
public void AutoRegister_WithConstructorDependencyThatHasOneDependentArgument_ReturnsTheResolvedInstanceFilledWithTheDependentArgument() {
var container = new NCopContainer(registry => {
registry.Register<IFoo>().From<Foo>();
registry.RegisterAuto<CtorDependency>();
});
var instance = container.Resolve<CtorDependency>();
Assert.IsNotNull(instance.Foo);
}
public void Resolve_InChildContainerUsesParentContainer_ReusesParentContainerAndReturnsTheReolvedObject() {
var container = new NCopContainer(registry => {
registry.Register<Foo>();
});
var childContainer = container.CreateChildContainer(registry => { });
var instance = childContainer.Resolve<Foo>();
Assert.IsNotNull(instance);
}
public void DisposeOfContainer_OfDisposableObjectWhichIsOwnedExternally_ReturnsNotDispsoedIndication() {
var container = new NCopContainer(registry => {
registry.Register<Foo>().OwnedExternally();
});
var instance = container.Resolve<Foo>();
Assert.IsFalse(instance.IsDisposed);
container.Dispose();
Assert.IsFalse(instance.IsDisposed);
}
public void AutoRegister_WithPropertyDependency_ReturnsTheResolvedInstanceFilledWithTheAutoResolvedProperty() {
var container = new NCopContainer(registry => {
registry.Register<IFoo>().From<Foo>();
registry.RegisterAuto<PropertyDependency>();
});
var instance = container.Resolve<PropertyDependency>();
Assert.IsNotNull(instance.Foo);
}
public void AutoRegister_OfTypeThatHasMoreThanOneConstructorAndWithoutDependencyAttribute_ThrowsRegistrationException() {
var container = new NCopContainer(registry => {
registry.Register<IFoo>().From<Foo>();
registry.RegisterAuto<AmbiguousConstructor>();
});
var instance = container.Resolve<AmbiguousConstructor>();
}
public CompositeContainerAdapter()
{
container = new NCopContainer();
}
public void Resolve_UsingAutoFactoryAndCastingWithAsExpressionAndAfterThatUsingTheAsSingletonExpressionRegistration_ReturnsTheSameObjectForDifferentResolveCalls() {
var container = new NCopContainer(registry => {
registry.Register<IFoo>().From<Foo>().AsSingleton();
});
var instance = container.Resolve<IFoo>();
var instatance2 = container.Resolve<IFoo>();
Assert.AreSame(instance, instatance2);
}
public void TryResolve_NotRegisteredService_DontThrowsRegistrationExceptionAndReturnsNull() {
var container = new NCopContainer(registry => { });
var instance = container.TryResolve<IFoo>();
Assert.IsNull(instance);
}
public void AutoRegister_OfTypeThatHasMoreThanOneConstructorWithDependencyAttribute_ReturnsResolvedInstanceAndDontThrowsRegistrationException() {
var container = new NCopContainer(registry => {
registry.Register<IFoo>().From<Foo>();
registry.RegisterAuto<AmbiguousConstructorFixedWithDependencyAttribute>();
});
var instance = container.Resolve<AmbiguousConstructorFixedWithDependencyAttribute>();
Assert.IsNotNull(instance);
Assert.IsNotNull(instance.Foo);
}
public void ResolveInChildContainerAndInParentContainer_UsingAutoRegistrationInParentContainerAsSingletoneReusedWithinHierarchy_ReturnsNotTheSameInstance() {
var container = new NCopContainer(registry => {
registry.Register<Foo>().AsSingleton().WithinContainer();
});
var childContainer = container.CreateChildContainer(registry => { });
var instance1 = container.Resolve<Foo>();
var instance2 = container.Resolve<Foo>();
var instance3 = childContainer.Resolve<Foo>();
var instance4 = childContainer.Resolve<Foo>();
Assert.AreSame(instance1, instance2);
Assert.AreNotSame(instance1, instance3);
Assert.AreSame(instance3, instance4);
}
public void AutoRegister_OfInterfaceAndCastingWithAsExpressionToConcreteTypeThatHasOneDependentProperty_ReturnsResolvedInstanceWithFilledProperty() {
var container = new NCopContainer(registry => {
registry.Register<Baz>().ToSelf();
registry.RegisterAuto<IFoo>().From<Boo>();
});
var instance = container.Resolve<IFoo>() as Boo;
Assert.IsNotNull(instance);
Assert.IsNotNull(instance.Baz);
}
public void AutoRegister_OfTypeThatHasTwoPropertiesThatOneOfThemIsDependentAndTheOtherFilledByDependentConstructor_ReturnsResolvedInstanceWithBothPropertiesFilled() {
var container = new NCopContainer(registry => {
registry.Register<IFoo>().From<Foo>().AsSingleton();
registry.RegisterAuto<Bar>();
});
var instance = container.Resolve<Bar>();
Assert.IsNotNull(instance.ByCtor);
Assert.IsNotNull(instance.ByProperty);
Assert.AreSame(instance.ByCtor, instance.ByProperty);
}
public async Task Resolve_UsingAsPerHybridRequestExpressionRegistrationWhenHttpContextIsNotAvailable_ReturnsTheSameInstancePerThreadRequest() {
Foo foo = null;
Foo foo2 = null;
NCopContainer container = null;
container = new NCopContainer(registry => {
registry.Register<Foo>().AsSingleton().PerHybridRequest();
});
foo = container.Resolve<Foo>();
Assert.AreEqual(foo, container.Resolve<Foo>());
foo2 = await Task.Factory.StartNew(() => container.Resolve<Foo>());
Assert.AreEqual(foo, foo2);
}
public void TryResolve_NotRegisteredService_ThrowsRegistrationException()
{
var container = new NCopContainer(registry => { });
var instance = container.Resolve <IFoo>();
}
public void ResolveInChildContainerAndInParentContainer_UsingSingletonRegistrationInParentContainer_ReturnsTheSameInstance() {
var container = new NCopContainer(registry => {
registry.Register<Foo>().AsSingleton().WithinHierarchy();
});
var childContainer = container.CreateChildContainer(registry => { });
var instance = container.Resolve<Foo>();
var instance2 = childContainer.Resolve<Foo>();
Assert.AreSame(instance, instance2);
}
public void Resolve_UsingAutoFactoryOfInterfaceThatBindsToSelf_ThrowsRegistrationException() {
var container = new NCopContainer(registry => {
registry.Register<IFoo>().ToSelf();
});
container.Resolve<IFoo>();
}
public void Resolve_UsingAutoFactoryThatBindsToSelf_ReturnsTheResolvedInstance() {
var container = new NCopContainer(registry => {
registry.Register<Foo>().ToSelf();
});
var instance = container.Resolve<Foo>();
Assert.IsNotNull(instance);
Assert.IsInstanceOfType(instance, typeof(Foo));
}
public void TryResolve_NotRegisteredService_ThrowsRegistrationException() {
var container = new NCopContainer(registry => { });
container.Resolve<IFoo>();
}
public void AutoRegister_OfTypeThatHasTwoDependentPropertiesThatOneOfThemIsAnnotatedWithIgnoreDependency_ReturnsResolvedInstanceWithOnlyOneDependentProperty() {
var container = new NCopContainer(registry => {
registry.Register<IFoo>().From<Foo>();
registry.RegisterAuto<IgnoreDependencyClass>();
});
var instance = container.Resolve<IgnoreDependencyClass>();
Assert.IsNotNull(instance.Injected);
Assert.IsNull(instance.Ignored);
}
public async Task Resolve_UsingAsPerThreadSingletonExpressionRegistrationWithAutoFactory_ReturnsDiffrentOjectsForDiffrentThreadsAndTheSameObjectForDifferentResolveCallsOnTheSameThread() {
Foo foo1 = null;
Foo foo2 = null;
var container = new NCopContainer(registry => {
registry.Register<Foo>().AsSingleton().PerThread();
});
foo1 = await Task.Factory.StartNew(() => container.Resolve<Foo>());
foo2 = await Task.Factory.StartNew(() => container.Resolve<Foo>());
Assert.AreNotEqual(foo1, foo2);
Assert.AreEqual(container.Resolve<Foo>(), container.Resolve<Foo>());
}
public void DisposeOfParentContainer_OfDisposableObjectWhichIsOwnedByChildContainer_ReturnsDispsoedIndication() {
var parentContainer = new NCopContainer(registry => {
});
var childContainer = parentContainer.CreateChildContainer(registry => {
registry.Register<Foo>();
});
var instance = childContainer.Resolve<Foo>();
Assert.IsFalse(instance.IsDisposed);
parentContainer.Dispose();
Assert.IsFalse(instance.IsDisposed);
}
