public void StandardResolveTests_Resolve_Scoped_Injection_Factory()
{
using IStashboxContainer container = new StashboxContainer();
container.RegisterScoped(typeof(ITest1), typeof(Test1));
container.RegisterScoped <ITest4, Test4>();
using var scope = container.BeginScope();
var factory = scope.ResolveFactory <ITest4>();
var inst = factory();
var inst2 = factory();
Assert.Same(inst.Test, inst2.Test);
Assert.Same(inst.Test2, inst2.Test2);
Assert.Same(inst.Test, inst2.Test2);
using var child = container.BeginScope();
var scopedFactory = child.ResolveFactory <ITest4>();
var inst3 = scopedFactory();
var inst4 = scopedFactory();
Assert.NotSame(inst.Test, inst4.Test);
Assert.NotSame(inst.Test2, inst4.Test2);
Assert.NotSame(inst.Test, inst4.Test2);
Assert.Same(inst3.Test, inst4.Test);
Assert.Same(inst3.Test2, inst4.Test2);
Assert.Same(inst3.Test, inst4.Test2);
}
public void LifetimeTests_Scoped_Is_Not_Resolvable_From_Root_AfterResolved(bool enabledValidation)
{
using IStashboxContainer container = new StashboxContainer(c =>
{
if (enabledValidation)
{
c.WithLifetimeValidation();
}
});
container.Register <Test6>();
container.RegisterScoped <Test5>();
if (enabledValidation)
{
using var scope = container.BeginScope();
scope.Resolve <Test6>();
var exception = Assert.Throws <LifetimeValidationFailedException>(() => container.Resolve <Test6>());
Assert.Contains("from the root scope", exception.Message);
}
else
{
using var scope = container.BeginScope();
scope.Resolve <Test6>();
Assert.NotNull(container.Resolve <Test6>());
}
}
public void Ensure_Named_Scoped_Instance_Working()
{
using var container = new StashboxContainer()
.Register <A>();
var a1 = new A();
var a2 = new A();
var a3 = new A();
{
using var scope = container.BeginScope();
scope.PutInstanceInScope(a1);
scope.PutInstanceInScope(a2, name: "a");
scope.PutInstanceInScope(a2);
Assert.Same(a2, scope.Resolve <A>("a"));
}
{
using var scope = container.BeginScope();
scope.PutInstanceInScope(a1, name: "a1");
scope.PutInstanceInScope(a2, name: "a2");
scope.PutInstanceInScope(a2, name: "a3");
Assert.Same(a2, scope.Resolve <A>("a2"));
}
}
public void DisposeTests_PutInScope_Scoped()
{
using IStashboxContainer container = new StashboxContainer();
container.RegisterScoped <ITest2, Test2>();
container.RegisterScoped <Test3>();
var test = new Test1();
using (var child = container.BeginScope())
{
child.PutInstanceInScope <ITest1>(test);
var test1 = child.Resolve <ITest1>();
var test2 = child.Resolve <ITest2>();
var test3 = child.Resolve <Test3>();
Assert.Same(test, test1);
Assert.Same(test, test2.Test1);
Assert.Same(test, test3.Test1);
Assert.False(test.Disposed);
}
Assert.True(test.Disposed);
var test4 = new Test1();
using (var child = container.BeginScope())
{
child.PutInstanceInScope <ITest1>(test4);
var test1 = child.Resolve <ITest1>();
var test2 = child.Resolve <ITest2>();
var test3 = child.Resolve <Test3>();
Assert.Same(test4, test1);
Assert.Same(test4, test2.Test1);
Assert.Same(test4, test3.Test1);
Assert.NotSame(test, test1);
Assert.NotSame(test, test2.Test1);
Assert.NotSame(test, test3.Test1);
Assert.False(test4.Disposed);
}
Assert.True(test4.Disposed);
}
public void NamedScope_Cache(CompilerType compilerType)
{
var container = new StashboxContainer(c => c.WithCompiler(compilerType))
.Register <ITest, Test>(config => config.InNamedScope("A"))
.Register <ITest, Test1>();
using var scope = container.BeginScope();
var inst = scope.Resolve <ITest>();
Assert.IsType <Test1>(inst);
using var scope1 = container.BeginScope("A");
inst = scope1.Resolve <ITest>();
Assert.IsType <Test>(inst);
}
public void LifetimeTests_Scoped_WithNull()
{
using IStashboxContainer container = new StashboxContainer();
container.RegisterScoped <Test6>();
Assert.Null(container.BeginScope().Resolve <Test6>(nullResultAllowed: true));
}
public void StandardResolveTests_Resolve_Scoped_Injection()
{
using (IStashboxContainer container = new StashboxContainer())
{
container.RegisterScoped(typeof(ITest1), typeof(Test1));
container.RegisterScoped <ITest4, Test4>();
var inst = container.Resolve <ITest4>();
var inst2 = container.Resolve <ITest4>();
Assert.AreSame(inst.Test, inst2.Test);
Assert.AreSame(inst.Test2, inst2.Test2);
Assert.AreSame(inst.Test, inst2.Test2);
using (var child = container.BeginScope())
{
var inst3 = child.Resolve <ITest4>();
var inst4 = child.Resolve <ITest4>();
Assert.AreNotSame(inst.Test, inst4.Test);
Assert.AreNotSame(inst.Test2, inst4.Test2);
Assert.AreNotSame(inst.Test, inst4.Test2);
Assert.AreSame(inst3.Test, inst4.Test);
Assert.AreSame(inst3.Test2, inst4.Test2);
Assert.AreSame(inst3.Test, inst4.Test2);
}
}
}
public void RegisteredInstancesCanBeOverridenViaAFactory()
{
var container = new StashboxContainer();
var toInclude = new A {
Id = 20
};
container.RegisterInstance(toInclude);
var outer = container.Resolve <A>();
A inner1 = null;
A inner2 = null;
using (var scope = container.BeginScope())
{
inner1 = scope.Resolve <A>();
var toOverride = new A {
Id = 30
};
scope.PutInstanceInScope(toOverride);
inner2 = scope.Resolve <A>();
}
Assert.Equal(toInclude.Id, outer.Id);
Assert.Equal(toInclude.Id, inner1.Id);
Assert.Equal(30, inner2.Id);
}
public void LifetimeTests_Shorter_Lifetime_Not_Resolvable_From_Longer_InDirect(bool enabledValidation)
{
using IStashboxContainer container = new StashboxContainer(c =>
{
if (enabledValidation)
{
c.WithLifetimeValidation();
}
});
container.RegisterSingleton <Test8>();
container.Register <Test6>();
container.RegisterScoped <Test5>();
using var scope = container.BeginScope();
if (enabledValidation)
{
var exception = Assert.Throws <LifetimeValidationFailedException>(() => scope.Resolve <Test8>());
Assert.Contains("The life-span of", exception.Message);
}
else
{
Assert.NotNull(scope.Resolve <Test8>());
}
}
public void DisposeTests_TrackTransientDisposal_Scoped_Transient_Singleton()
{
var container = new StashboxContainer(config => config.WithDisposableTransientTracking());
container.Register <ITest2, Test2>();
container.Register <Test3>();
container.RegisterSingleton <ITest1, Test1>();
ITest1 test4;
ITest2 test5;
Test3 test6;
using (var child = container.BeginScope())
{
test4 = child.Resolve <ITest1>();
test5 = child.Resolve <ITest2>();
test6 = child.Resolve <Test3>();
Assert.IsFalse(test4.Disposed);
Assert.IsFalse(test5.Test1.Disposed);
Assert.IsFalse(test6.Test1.Disposed);
}
Assert.IsFalse(test4.Disposed);
Assert.IsFalse(test5.Test1.Disposed);
Assert.IsFalse(test6.Test1.Disposed);
container.Dispose();
Assert.IsTrue(test4.Disposed);
Assert.IsTrue(test5.Test1.Disposed);
Assert.IsTrue(test6.Test1.Disposed);
}
public void Ensure_expression_built_correctly_singleton_dispose_simple(CompilerType compilerType)
{
C.Counter = 0;
F inst = null;
{
using var container = new StashboxContainer(c =>
{
c.WithDisposableTransientTracking().WithCompiler(compilerType);
})
.Register <F>(c => c.WithScopedLifetime())
.Register <C>(c => c.WithSingletonLifetime());
{
using var scope = container.BeginScope();
inst = scope.Resolve <F>();
}
Assert.True(inst.Disposed);
Assert.False(inst.C.Disposed);
}
Assert.True(inst.C.Disposed);
Assert.Equal(1, C.Counter);
}
public void DisposeTests_PutInScope_WithoutDispose()
{
using (IStashboxContainer container = new StashboxContainer())
{
container.Register <ITest2, Test2>();
container.Register <Test3>();
var test = new Test1();
using (var child = container.BeginScope())
{
child.PutInstanceInScope <ITest1>(test, true);
var test1 = child.Resolve <ITest1>();
var test2 = child.Resolve <ITest2>();
var test3 = child.Resolve <Test3>();
Assert.AreSame(test, test1);
Assert.AreSame(test, test2.Test1);
Assert.AreSame(test, test3.Test1);
}
Assert.IsFalse(test.Disposed);
}
}
public void NamedScope_WithNull()
{
var container = new StashboxContainer()
.RegisterType <Test2>(config => config.InNamedScope("A"));
Assert.IsNull(container.BeginScope("A").Resolve <Test2>(nullResultAllowed: true));
}
public void RegistersTests_Registers_Configurator()
{
IStashboxContainer container = new StashboxContainer();
container.RegisterTypes(new[] { typeof(Test), typeof(Test1), typeof(Test11), typeof(Test12) }, configurator: context =>
{
if (context.ServiceType == typeof(ITest2))
{
context.WithScopedLifetime();
}
});
using var scope = container.BeginScope();
var test = scope.ResolveAll <ITest>();
var test1 = scope.ResolveAll <ITest1>();
var test2 = scope.ResolveAll <ITest2>();
var scopeds = container.ContainerContext.RegistrationRepository.GetRegistrationMappings().Where(r => r.Value.RegistrationContext.Lifetime is ScopedLifetime).ToArray();
Assert.Equal(3, test.Count());
Assert.Equal(3, test1.Count());
Assert.Equal(2, test2.Count());
Assert.Equal(2, scopeds.Length);
}
public void BuildUpTests_BuildUp_Scoped()
{
using (var container = new StashboxContainer())
{
container.RegisterScoped <ITest, Test>();
var test1 = new Test1();
var test2 = new Test2();
using (var scope = container.BeginScope())
{
container.WireUpAs <ITest1>(test1);
var inst = scope.BuildUp(test2);
Assert.AreEqual(test2, inst);
Assert.IsNotNull(inst);
Assert.IsNotNull(inst.Test1);
Assert.IsInstanceOfType(inst, typeof(Test2));
Assert.IsInstanceOfType(inst.Test1, typeof(Test1));
Assert.IsInstanceOfType(inst.Test1.Test, typeof(Test));
}
Assert.IsTrue(test1.Test.Disposed);
Assert.IsTrue(test2.Test1.Test.Disposed);
}
}
public void Ensure_expression_built_correctly_scoped(CompilerType compilerType)
{
A.Counter = 0;
B.Counter = 0;
C.Counter = 0;
D.Counter = 0;
E.Counter = 0;
F.Counter = 0;
A inst = null;
{
using var container = new StashboxContainer(c => c.WithRuntimeCircularDependencyTracking()
.WithDisposableTransientTracking()
.WithCompiler(compilerType))
.Register <A>(c => c.WithScopedLifetime())
.Register <B>(c => c.WithScopedLifetime())
.Register <D>(c => c.WithScopedLifetime())
.Register <E>(c => c.WithScopedLifetime())
.Register <F>(c => c.WithScopedLifetime())
.Register <C>(c => c.WithFactory(r => new C()).WithScopedLifetime().WithoutDisposalTracking());
using var scope = container.BeginScope();
inst = scope.Resolve <A>();
Assert.NotNull(inst);
Assert.NotNull(inst.B);
Assert.NotNull(inst.C);
Assert.NotNull(inst.B.D);
Assert.NotNull(inst.B.C);
Assert.NotNull(inst.B.D.C);
Assert.NotNull(inst.B.D.E);
Assert.NotNull(inst.B.D.F);
Assert.NotNull(inst.B.D.E.C);
Assert.NotNull(inst.B.D.F.C);
Assert.Same(inst.C, inst.B.C);
Assert.Same(inst.B.C, inst.B.D.C);
Assert.Same(inst.B.D.C, inst.B.D.E.C);
Assert.Same(inst.B.D.E.C, inst.B.D.F.C);
}
Assert.True(inst.Disposed);
Assert.True(inst.B.Disposed);
Assert.False(inst.C.Disposed);
Assert.True(inst.B.D.Disposed);
Assert.False(inst.B.C.Disposed);
Assert.False(inst.B.D.C.Disposed);
Assert.True(inst.B.D.E.Disposed);
Assert.True(inst.B.D.F.Disposed);
Assert.False(inst.B.D.E.C.Disposed);
Assert.False(inst.B.D.F.C.Disposed);
Assert.Equal(1, A.Counter);
Assert.Equal(1, B.Counter);
Assert.Equal(1, C.Counter);
Assert.Equal(1, D.Counter);
Assert.Equal(1, E.Counter);
Assert.Equal(1, F.Counter);
}
public void GenericTests_Resolve_Prefer_Open_Generic_Enumerable_In_Named_Scope()
{
var container = new StashboxContainer(config => config.WithUniqueRegistrationIdentifiers())
.RegisterType <ITest1 <int, string>, Test1 <int, string> >(config => config.InNamedScope("A"))
.RegisterType(typeof(ITest1 <,>), typeof(Test1 <,>), config => config.InNamedScope("A"));
var res = container.BeginScope("A").Resolve <IEnumerable <ITest1 <int, string> > >();
Assert.AreEqual(2, res.Count());
}
public void StandardResolveTests_Factory_Scoped()
{
using IStashboxContainer container = new StashboxContainer();
container.Register <ITest1, Test1>();
using var child = container.BeginScope();
var test1 = child.ResolveFactory(typeof(ITest1)).DynamicInvoke();
Assert.NotNull(test1);
Assert.IsType <Test1>(test1);
}
public void EnumerableTests_Resolve_Scoped_Lazy_Null()
{
IStashboxContainer container = new StashboxContainer();
var child = container.BeginScope();
var all = child.Resolve <IEnumerable <Lazy <ITest1> > >();
Assert.Empty(all);
}
public void GenericTests_Resolve_Prefer_Open_Generic_In_Named_Scope()
{
var container = new StashboxContainer(config => config.WithUniqueRegistrationIdentifiers())
.RegisterType <ITest1 <int, string>, Test1 <int, string> >()
.RegisterType(typeof(ITest1 <,>), typeof(Test1 <,>), config => config.InNamedScope("A"));
container.BeginScope("A").Resolve <ITest1 <int, string> >();
Assert.AreEqual(3, container.ContainerContext.RegistrationRepository.GetAllRegistrations().Count());
}
public void StandardResolveTests_Resolve_Scoped()
{
using IStashboxContainer container = new StashboxContainer();
container.RegisterScoped <ITest1, Test1>();
using var scope = container.BeginScope();
var inst = scope.Resolve <ITest1>();
var inst2 = scope.Resolve <ITest1>();
Assert.Same(inst, inst2);
using var child = container.BeginScope();
var inst3 = child.Resolve <ITest1>();
var inst4 = child.Resolve <ITest1>();
Assert.NotSame(inst, inst3);
Assert.Same(inst3, inst4);
}
public void StandardResolveTests_Ensure_DependencyResolver_CanBeResolved()
{
using IStashboxContainer container = new StashboxContainer();
container.RegisterScoped <ResolverTest>();
using var scope = container.BeginScope();
var resolver = scope.Resolve <IDependencyResolver>();
var test = scope.Resolve <ResolverTest>();
Assert.Same(resolver, test.DependencyResolver);
using var scope1 = container.BeginScope();
var scopedResolver = scope1.Resolve <IDependencyResolver>();
var test1 = scope1.Resolve <ResolverTest>();
Assert.Same(scope1, scopedResolver);
Assert.Same(scope1, test1.DependencyResolver);
}
public void ResolveFactoryTests_ParameterLess_Scoped(CompilerType compilerType)
{
using var container = new StashboxContainer(c => c.WithCompiler(compilerType));
container.Register <Test>();
using var scope = container.BeginScope();
var factory = scope.ResolveFactory <Test>();
Assert.NotNull(factory());
}
public void EnumerableTests_Resolve_Scoped_Func_Null()
{
IStashboxContainer container = new StashboxContainer();
var child = container.BeginScope();
var all = child.Resolve <IEnumerable <Func <ITest1> > >();
Assert.AreEqual(0, all.Count());
}
public void FactoryTests_Resolve_Gets_The_Proper_Scope(CompilerType compilerType)
{
using var container = new StashboxContainer(c => c.WithCompiler(compilerType));
container.Register <Test5>(context =>
context.WithFactory(resolver => new Test5(resolver)));
using var scope = container.BeginScope();
var t = scope.Resolve <Test5>();
Assert.Same(scope, t.DependencyResolver);
}
public void GenericTests_Resolve_Prefer_Open_Generic_In_Named_Scope()
{
var container = new StashboxContainer(config => config
.WithRegistrationBehavior(Rules.RegistrationBehavior.PreserveDuplications))
.Register <ITest1 <int, string>, Test1 <int, string> >()
.Register(typeof(ITest1 <,>), typeof(Test1 <,>), config => config.InNamedScope("A"));
container.BeginScope("A").Resolve <ITest1 <int, string> >();
Assert.Equal(2, container.ContainerContext.RegistrationRepository.GetRegistrationMappings().Count());
}
public void GenericTests_Resolve_Prefer_Open_Generic_Enumerable_In_Named_Scope()
{
var container = new StashboxContainer(config => config
.WithRegistrationBehavior(Rules.RegistrationBehavior.PreserveDuplications))
.Register <ITest1 <int, string>, Test1 <int, string> >(config => config.InNamedScope("A"))
.Register(typeof(ITest1 <,>), typeof(Test1 <,>), config => config.InNamedScope("A"));
var res = container.BeginScope("A").Resolve <IEnumerable <ITest1 <int, string> > >();
Assert.Equal(2, res.Count());
}
public void DisposeTests_Scoped()
{
ITest1 test;
ITest2 test2;
Test3 test3;
using (IStashboxContainer container = new StashboxContainer())
{
ITest1 test4;
ITest2 test5;
Test3 test6;
container.RegisterScoped <ITest2, Test2>();
container.RegisterScoped <Test3>();
container.RegisterScoped <ITest1, Test1>();
container.RegisterScoped <ITest11, Test4>();
container.RegisterScoped <ITest1, Test1>("test");
container.RegisterScoped <ITest11, Test4>("test2");
using var scope = container.BeginScope();
test = scope.Resolve <ITest1>();
var a = scope.Resolve <ITest11>();
test2 = scope.Resolve <ITest2>();
test3 = scope.Resolve <Test3>();
using (var child = container.BeginScope())
{
test4 = (ITest1)child.Resolve(typeof(ITest1), "test");
test5 = child.Resolve <ITest2>();
test6 = child.Resolve <Test3>();
}
Assert.True(test4.Disposed);
Assert.True(test5.Test1.Disposed);
Assert.True(test6.Test1.Disposed);
}
Assert.True(test.Disposed);
Assert.True(test2.Test1.Disposed);
Assert.True(test3.Test1.Disposed);
}
public void EnumerableTests_Resolve_Scoped_Null()
{
IStashboxContainer container = new StashboxContainer();
var scope = container.BeginScope();
var all = scope.Resolve <IEnumerable <ITest2> >();
var all2 = scope.ResolveAll <ITest2>();
Assert.Empty(all);
Assert.Empty(all2);
}
public void EnumerableTests_Resolve_Scoped_Null()
{
IStashboxContainer container = new StashboxContainer();
var scope = container.BeginScope();
var all = scope.Resolve <IEnumerable <ITest2> >();
var all2 = scope.ResolveAll <ITest2>();
Assert.AreEqual(0, all.Count());
Assert.AreEqual(0, all2.Count());
}
