public void StandardResolveTests_DependencyResolve_ResolutionFailed()
{
using (IStashboxContainer container = new StashboxContainer())
{
container.RegisterType<ITest2, Test2>();
var test2 = container.Resolve<ITest2>();
}
}
public void ContainerTests_ResolverTest()
{
var container = new StashboxContainer();
container.RegisterResolver<TestResolver>((context, typeInfo) => typeInfo.Type == typeof(ITest1),
(context, typeInfo) => new TestResolver(context, typeInfo));
var inst = container.Resolve<ITest1>();
Assert.IsInstanceOfType(inst, typeof(Test1));
}
private static IStashboxContainer ConfigureContainer()
{
var container = new StashboxContainer();
RegisterServices(container);
DependencyResolver.SetResolver(new StashboxDependencyResolver(container));
return container;
}
public void FuncTests_Resolve()
{
var container = new StashboxContainer();
container.RegisterType<ITest, Test>();
var inst = container.Resolve<Func<ITest>>();
Assert.IsNotNull(inst);
Assert.IsInstanceOfType(inst, typeof(Func<ITest>));
Assert.IsInstanceOfType(inst(), typeof(Test));
}
public void InstanceBuilderTests_Resolve()
{
using (var container = new StashboxContainer())
{
var dep = new Test();
container.RegisterInstance<ITest>(dep);
var inst = container.Resolve<ITest>();
Assert.AreSame(inst, dep);
}
}
public void LazyTests_Resolve()
{
var container = new StashboxContainer();
container.RegisterType<ITest, Test>();
var inst = container.Resolve<Lazy<ITest>>();
Assert.IsNotNull(inst);
Assert.IsFalse(inst.IsValueCreated);
Assert.IsInstanceOfType(inst, typeof(Lazy<ITest>));
Assert.IsInstanceOfType(inst.Value, typeof(Test));
}
public void ContainerTests_IsRegistered()
{
var container = new StashboxContainer();
container.RegisterType<ITest1, Test1>();
container.RegisterType<ITest2, Test2>();
Assert.IsTrue(container.IsRegistered<ITest1>());
Assert.IsTrue(container.IsRegistered(typeof(ITest2)));
Assert.IsFalse(container.IsRegistered<ITest3>());
Assert.IsFalse(container.IsRegistered<ITest1>("test"));
Assert.IsFalse(container.IsRegistered(typeof(ITest1), "test"));
}
public void FactoryBuildUpTests_Resolve()
{
using (var container = new StashboxContainer())
{
container.PrepareType<ITest, Test>().WithFactory(() => new Test("test")).Register();
container.RegisterType<ITest1, Test1>();
var inst = container.Resolve<ITest1>();
Assert.IsInstanceOfType(inst.Test, typeof(Test));
Assert.AreEqual("test", inst.Test.Name);
}
}
public void FactoryBuildUpTests_DependencyResolve_ServiceUpdated()
{
using (var container = new StashboxContainer())
{
container.PrepareType<ITest, Test>().WithFactory(() => new Test("test")).Register();
container.RegisterType<ITest2, Test2>();
container.PrepareType<ITest, Test>().WithFactory(() => new Test("test1")).ReMap();
var inst = container.Resolve<ITest2>();
Assert.IsInstanceOfType(inst.Test, typeof(Test));
Assert.AreEqual("test1", inst.Test.Name);
}
}
public void ConditionalTests_AttributeCondition_Second()
{
var container = new StashboxContainer();
container.RegisterType<ITest1, Test1>();
container.PrepareType<ITest1, Test11>().WhenHas<TestCondition2Attribute>().Register();
container.PrepareType<ITest1, Test12>().WhenHas<TestConditionAttribute>().Register();
container.RegisterType<ITest2, Test3>();
var test3 = container.Resolve<ITest2>();
Assert.IsInstanceOfType(test3.test1, typeof(Test12));
Assert.IsInstanceOfType(test3.test12, typeof(Test11));
}
public void DecoratorExtensionsTests_WithoutExtension()
{
using (var cont = new StashboxContainer())
{
cont.PrepareType<ITest1, Test1>().DecorateWith<TestDecorator1>().Register();
cont.RegisterDecorator<ITest1, TestDecorator2>();
var test = cont.Resolve<ITest1>();
Assert.IsNotNull(test);
Assert.IsInstanceOfType(test, typeof(Test1));
Assert.IsNull(test.Test);
}
}
public void BuildExtensionManagerTests_AddRegistrationBuildExtension()
{
var post = new Mock<IRegistrationExtension>();
using (var container = new StashboxContainer())
{
container.RegisterExtension(post.Object);
container.RegisterInstance(new object());
post.Verify(p => p.Initialize(container.ContainerContext));
post.Verify(p => p.OnRegistration(container.ContainerContext,
It.IsAny<RegistrationInfo>(), null));
}
post.Verify(p => p.CleanUp());
}
public void InjectionMemberTests_BuildUp_WithoutService()
{
using (var container = new StashboxContainer())
{
container.RegisterType<ITest, Test>();
var test1 = new Test1();
container.BuildUp(test1);
var inst = container.Resolve<Test1>();
Assert.IsNotNull(inst);
Assert.IsNotNull(inst.Test);
Assert.IsInstanceOfType(inst, typeof(Test1));
Assert.IsInstanceOfType(inst.Test, typeof(Test));
}
}
public void ContainerTests_ChildContainer()
{
var container = new StashboxContainer();
container.RegisterType<ITest1, Test1>();
container.RegisterType<ITest2, Test2>();
var child = container.CreateChildContainer();
child.RegisterType<ITest3, Test3>();
var test3 = child.Resolve<ITest3>();
Assert.IsNotNull(test3);
Assert.IsInstanceOfType(test3, typeof(Test3));
Assert.AreEqual(container, child.ParentContainer);
}
public void ReMapTests_Lazy()
{
IStashboxContainer container = new StashboxContainer();
container.RegisterType <ITest1, Test1>();
var lazy = container.Resolve <Lazy <ITest1> >();
Assert.IsInstanceOfType(lazy.Value, typeof(Test1));
container.ReMap <ITest1, Test11>();
var lazy2 = container.Resolve <Lazy <ITest1> >();
Assert.IsInstanceOfType(lazy2.Value, typeof(Test11));
}
public void InjectionMemberTests_Resolve()
{
using var container = new StashboxContainer();
container.Register <ITest, Test>();
container.Register <ITest1, Test1>();
var inst = container.Resolve <ITest1>();
Assert.NotNull(inst);
Assert.NotNull(inst.Test);
Assert.IsType <Test1>(inst);
Assert.IsType <Test>(inst.Test);
Assert.NotNull(((Test1)inst).TestFieldProperty);
Assert.IsType <Test>(((Test1)inst).TestFieldProperty);
}
public void ReMapTests_Enumerable()
{
IStashboxContainer container = new StashboxContainer();
container.RegisterType <ITest1, Test1>();
var coll = container.Resolve <IEnumerable <ITest1> >().ToArray();
Assert.IsInstanceOfType(coll[0], typeof(Test1));
container.ReMap <ITest1, Test11>();
var coll2 = container.Resolve <IEnumerable <ITest1> >().ToArray();
Assert.IsInstanceOfType(coll2[0], typeof(Test11));
}
public void ReMapTests_Func()
{
IStashboxContainer container = new StashboxContainer();
container.RegisterType <ITest1, Test1>();
var func = container.Resolve <Func <ITest1> >();
Assert.IsInstanceOfType(func(), typeof(Test1));
container.ReMap <ITest1, Test11>();
var func2 = container.Resolve <Func <ITest1> >();
Assert.IsInstanceOfType(func2(), typeof(Test11));
}
public void Generate_one_instance_for_multiple_interfaces()
{
var container = new StashboxContainer();
container.Register <Test2>(context => context.AsImplementedTypes());
var inst1 = container.Resolve <ITest>();
var inst2 = container.Resolve <ITest1>();
var inst3 = container.Resolve <ITest2>();
var inst4 = container.Resolve <Test>();
var inst5 = container.Resolve <Test2>();
Assert.NotSame(inst1, inst2);
Assert.NotSame(inst2, inst3);
Assert.NotSame(inst3, inst4);
Assert.NotSame(inst4, inst5);
}
public async Task FuncTests_Register_FuncDelegate_Async_Longrun()
{
var container = new StashboxContainer();
var test = new Test();
container.RegisterInstance(test);
container.RegisterFunc(async resolver =>
{
await Task.Delay(1000);
return(resolver.Resolve <Test>());
});
var inst = await container.Resolve <Func <Task <Test> > >()();
Assert.Same(test, inst);
}
public void InjectionMemberTests_Resolve()
{
var container = new StashboxContainer();
container.RegisterType<ITest, Test>();
container.RegisterType<ITest1, Test1>();
var inst = container.Resolve<ITest1>();
Assert.IsNotNull(inst);
Assert.IsNotNull(inst.Test);
Assert.IsInstanceOfType(inst, typeof(Test1));
Assert.IsInstanceOfType(inst.Test, typeof(Test));
Assert.IsNotNull(((Test1)inst).TestFieldProperty);
Assert.IsInstanceOfType(((Test1)inst).TestFieldProperty, typeof(Test));
}
public void EnumerableTests_Resolve_PreserveOrder_Parent_Func()
{
IStashboxContainer container = new StashboxContainer();
container.RegisterType <ITest1, Test1>();
container.RegisterType <ITest1, Test11>();
container.RegisterType <ITest1, Test12>();
var child = container.CreateChildContainer();
var services = child.Resolve <IEnumerable <Func <ITest1> > >().ToArray();
Assert.IsInstanceOfType(services[0](), typeof(Test1));
Assert.IsInstanceOfType(services[1](), typeof(Test11));
Assert.IsInstanceOfType(services[2](), typeof(Test12));
}
public void OverrideTests_Resolve_Factory_NonGeneric_DerivedParam()
{
IStashboxContainer container = new StashboxContainer();
container.RegisterType <ITest2, Test2>();
var inst1 = new Test1 {
Name = "test"
};
var factory = container.ResolveFactory(typeof(ITest2), parameterTypes: inst1.GetType());
var inst2 = (ITest2)factory.DynamicInvoke(inst1);
Assert.IsNotNull(inst2);
Assert.AreEqual("test", inst2.Name);
}
public void NamedScope_Preserve_Instance_Through_Nested_Scopes()
{
var container = new StashboxContainer()
.Register <ITest, Test>(config => config.InNamedScope("A"));
using (var s1 = container.BeginScope("A"))
{
var i1 = s1.Resolve <ITest>();
using (var s2 = s1.BeginScope("C"))
{
var i2 = s2.Resolve <ITest>();
Assert.AreSame(i2, i1);
}
}
}
public void Composition_Test_Enumerable_MultipleDecorators()
{
using var container = new StashboxContainer()
.Register <IA, A>()
.Register <IA, AA>()
.RegisterDecorator <IA, AD>()
.RegisterDecorator <IA, D2>();
var d = container.Resolve <IA>();
Assert.IsType <D2>(d);
Assert.IsType <AD>(((D2)d).A.ElementAt(0));
Assert.IsType <A>(((AD)((D2)d).A.ElementAt(0)).A);
Assert.IsType <AD>(((D2)d).A.ElementAt(1));
Assert.IsType <AA>(((AD)((D2)d).A.ElementAt(1)).A);
}
public void WireUpTests_WithoutService_NonGeneric()
{
using var container = new StashboxContainer();
container.RegisterSingleton <ITest, Test>();
object test1 = new Test1();
container.WireUp(test1, typeof(Test1));
var inst = container.Resolve <Test1>();
Assert.NotNull(inst);
Assert.NotNull(inst.Test);
Assert.NotNull(inst.test);
Assert.IsType <Test1>(inst);
Assert.IsType <Test>(inst.Test);
Assert.IsType <Test>(inst.test);
}
public async Task Disposes_Either_Normal_And_Async()
{
AsyncDisposable asyncDisposable;
Disposable disposable;
{
await using var container = new StashboxContainer(c => c.WithDisposableTransientTracking())
.Register <AsyncDisposable>()
.Register <Disposable>();
asyncDisposable = container.Resolve <AsyncDisposable>();
disposable = container.Resolve <Disposable>();
}
Assert.True(asyncDisposable.Disposed);
Assert.True(disposable.Disposed);
}
public void MultitenantTests_Configure_Dep()
{
var container = new StashboxContainer();
container.Register <D>();
container.Register <IA, A>();
var md = new TenantDistributor(container);
md.ConfigureTenant("A", c => c.Register <IA, B>());
var tenant = md.GetTenant("A");
Assert.IsType <A>(container.Resolve <D>().Ia);
Assert.IsType <B>(md.GetTenant("A").Resolve <D>().Ia);
}
public void FuncTests_Resolve_ParameterInjection_3Params()
{
var container = new StashboxContainer();
container.RegisterType <IFTest3, FTest3>();
var inst = container.Resolve <Func <ITest, IFTest1, IFTest2, IFTest3> >();
var t = new Test();
var t1 = new FTest1();
var t2 = new FTest2(null);
var r = inst(t, t1, t2);
Assert.AreSame(t, r.Test);
Assert.AreSame(t1, r.Test1);
Assert.AreSame(t2, r.Test2);
}
public void DecoratorTests_AutoMemberInjection_InjectionParameter_Fluent(CompilerType compilerType)
{
using var container = new StashboxContainer(c => c.WithCompiler(compilerType));
container.Register <ITest1, Test1>();
container.RegisterDecorator <ITest1, TestDecorator4>(context => context
.WithAutoMemberInjection(Rules.AutoMemberInjectionRules.PropertiesWithLimitedAccess)
.WithInjectionParameter("Name", "test"));
var test = container.Resolve <ITest1>();
Assert.NotNull(test);
Assert.IsType <TestDecorator4>(test);
Assert.NotNull(test.Test);
Assert.IsType <Test1>(test.Test);
Assert.Equal("test", ((TestDecorator4)test).Name);
}
public void EnumerableTests_Resolve_PreserveOrder_Scoped_Lazy()
{
IStashboxContainer container = new StashboxContainer();
container.RegisterType <ITest1, Test1>();
container.RegisterType <ITest1, Test11>();
container.RegisterType <ITest1, Test12>();
var child = container.BeginScope();
var services = child.Resolve <IEnumerable <Lazy <ITest1> > >().ToArray();
Assert.IsInstanceOfType(services[0].Value, typeof(Test1));
Assert.IsInstanceOfType(services[1].Value, typeof(Test11));
Assert.IsInstanceOfType(services[2].Value, typeof(Test12));
}
public void Ensure_Expression_Override_Does_Not_Mess_Up_Cache()
{
var proxyBuilder = new DefaultProxyBuilder();
using var container = new StashboxContainer().Register <IInterceptor, NoInterceptor>()
.RegisterDecorator <ILevel2Service>(proxyBuilder.CreateInterfaceProxyTypeWithTargetInterface(typeof(ILevel2Service), new Type[0], ProxyGenerationOptions.Default))
.RegisterDecorator <ILevel2bService>(proxyBuilder.CreateInterfaceProxyTypeWithTargetInterface(typeof(ILevel2bService), new Type[0], ProxyGenerationOptions.Default))
.RegisterDecorator <ILevel3Service>(proxyBuilder.CreateInterfaceProxyTypeWithTargetInterface(typeof(ILevel3Service), new Type[0], ProxyGenerationOptions.Default))
.RegisterScoped <ILevel1Service, Level1Service>()
.RegisterScoped <ILevel2Service, Level2Service>()
.RegisterScoped <ILevel2bService, Level2bService>()
.RegisterScoped <ILevel3Service, Level3Service>()
.RegisterScoped <ILevel4Service, Level4Service>();
Assert.NotNull(container.Resolve <ILevel2Service>());
}
public void NamedScope_Simple_Resolve_Gets_Named_When_Scoped_Doesnt_Exist(CompilerType compilerType)
{
using var scope = new StashboxContainer(config => config.WithCompiler(compilerType))
.Register <ITest, Test11>()
.Register <ITest, Test>(config => config.WithName("T"))
.Register <ITest, Test1>()
.BeginScope("A");
var a = scope.Resolve <ITest>("T");
var b = scope.Resolve <ITest>("T");
var c = scope.Resolve <ITest>();
Assert.IsType <Test1>(c);
Assert.IsType <Test>(b);
Assert.IsType <Test>(a);
}
public void FinalizerTests_Register_Scoped_Multiple_Shouldnt_Throw()
{
using var container = new StashboxContainer();
container.Register <ITest, Test>(context => context.WithFinalizer(t => t.Method()).WithScopedLifetime());
for (var i = 0; i < 10; i++)
{
ITest test;
using (var scope = container.BeginScope())
{
test = scope.Resolve <ITest>();
Assert.False(test.MethodCalled);
}
Assert.True(test.MethodCalled);
}
}
public void DependencyBindingTests_Bind_To_Different_Types()
{
var inst = new StashboxContainer()
.Register <ITest1, Test1>("test1")
.Register <ITest1, Test11>("test2")
.Register <ITest1, Test12>("test3")
.Register <Test>(ctx => ctx
.WithDependencyBinding("test1", "test1")
.WithDependencyBinding("test2", "test2")
.WithDependencyBinding("test3", "test3"))
.Resolve <Test>();
Assert.IsType <Test1>(inst.Test1);
Assert.IsType <Test11>(inst.Test2);
Assert.IsType <Test12>(inst.Test3);
}
public void GenericTests_Nested_Generics_Decorator()
{
var inst = new StashboxContainer()
.Register(typeof(IGen3 <>), typeof(Gen3 <>))
.RegisterDecorator(typeof(IGen3 <>), typeof(Gen3Decorator <>))
.Register <ConstraintArgument>()
.Resolve <IGen3 <ConstraintArgument> >();
Assert.NotNull(inst.Value);
Assert.IsType <ConstraintArgument>(inst.Value);
var decorator = (Gen3Decorator <ConstraintArgument>)inst;
Assert.NotNull(decorator.Decorated);
Assert.IsType <Gen3 <ConstraintArgument> >(decorator.Decorated);
}
public void RegistersTests_RegisterAssembly_Configurator_AsSelf()
{
IStashboxContainer container = new StashboxContainer();
container.RegisterAssemblyContaining <ITest1>(configurator: context =>
{
if (context.ServiceType == typeof(Test1))
{
context.WithScopedLifetime();
}
});
var regs = container.ContainerContext.RegistrationRepository.GetRegistrationMappings().Where(r => r.Value.RegistrationContext.Lifetime is ScopedLifetime).ToArray();
Assert.IsTrue(regs.Length > 0);
}
public void NamedScope_Simple_Resolve_Gets_Named_When_Scoped_Doesnt_Exist()
{
var scope = new StashboxContainer()
.Register <ITest, Test11>()
.Register <ITest, Test>(config => config.WithName("T"))
.Register <ITest, Test1>()
.BeginScope("A");
var a = scope.Resolve <ITest>("T");
var b = scope.Resolve <ITest>("T");
var c = scope.Resolve <ITest>();
Assert.IsInstanceOfType(c, typeof(Test1));
Assert.IsInstanceOfType(b, typeof(Test));
Assert.IsInstanceOfType(a, typeof(Test));
}
public void NamedScope_Simple_Resolve_Gets_Named_Within_Scope()
{
var scope = new StashboxContainer()
.Register <ITest, Test11>(config => config.InNamedScope("A"))
.Register <ITest, Test>(config => config.InNamedScope("A").WithName("T"))
.Register <ITest, Test1>(config => config.InNamedScope("A"))
.BeginScope("A");
var a = scope.Resolve <ITest>("T");
var b = scope.Resolve <ITest>("T");
var c = scope.Resolve <ITest>();
Assert.AreSame(a, b);
Assert.AreNotSame(a, c);
Assert.IsInstanceOfType(a, typeof(Test));
}
public void ContextEstablishedInChildContainersCanBeAccessedWhenUsingAParentScopeConstruction()
{
StashboxContainer sb1 = CreateContainer(c => c.WithSingletonLifetime());
StashboxContainer sb2 = CreateContainer(c => c.WithSingletonLifetime());
// This works
sb1.PutInstanceInScope(typeof(PrivateArgs <ITier2>), PrivateArgs <ITier2> .Get("Bob"));
sb1.PutInstanceInScope(typeof(PrivateArgs <TierBase>), PrivateArgs <TierBase> .Get(5));
ITier1 renderer = (ITier1)sb1.Resolve(typeof(ITier1));
using var scope = sb2.BeginScope();
scope.PutInstanceInScope(typeof(PrivateArgs <ITier2>), PrivateArgs <ITier2> .Get("Bob"));
scope.PutInstanceInScope(typeof(PrivateArgs <TierBase>), PrivateArgs <TierBase> .Get(5));
ITier1 renderer2 = (ITier1)scope.Resolve(typeof(ITier1));
}
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 RegistersTests_AsImplementedTypes_BaseType()
{
var container = new StashboxContainer();
container.Register <Test14>(context => context.AsImplementedTypes());
var regs = container.ContainerContext.RegistrationRepository.GetRegistrationMappings().OrderBy(r => r.Key.Name).ToArray();
Assert.AreEqual(6, regs.Length);
Assert.AreSame(regs[0].Key, typeof(ITest));
Assert.AreSame(regs[1].Key, typeof(ITest1));
Assert.AreSame(regs[2].Key, typeof(ITest2));
Assert.AreSame(regs[3].Key, typeof(Test12));
Assert.AreSame(regs[4].Key, typeof(Test13));
Assert.AreSame(regs[5].Key, typeof(Test14));
}
public void ContainerTests_CheckRegistration()
{
using (var container = new StashboxContainer())
{
container.Register <ITest1, Test1>();
var reg = container.ContainerContext.RegistrationRepository
.GetRegistrationMappings().FirstOrDefault(r => r.Key == typeof(ITest1));
Assert.IsNotNull(reg);
reg = container.ContainerContext.RegistrationRepository.GetRegistrationMappings().FirstOrDefault(r => r.Value.ImplementationType == typeof(Test1));
Assert.IsNotNull(reg);
}
}
static void Main(string[] args)
{
using (var container = new StashboxContainer())
{
//container.PrepareType<IFirstService, FirstService>().WithLifetime(new SingletonLifetime()).Register();
//container.PrepareType<ISecondService, SecondService>().WithLifetime(new SingletonLifetime()).Register();
//container.PrepareType<IThirdService, ThirdService>().WithLifetime(new SingletonLifetime()).Register();
//container.RegisterType<ISubObjectOne, SubObjectOne>();
//container.RegisterType<ISubObjectTwo, SubObjectTwo>();
//container.RegisterType<ISubObjectThree, SubObjectThree>();
//container.RegisterType<IComplex1, Complex1>();
//container.RegisterType<IComplex2, Complex2>();
//container.RegisterType<IComplex3, Complex3>();
container.RegisterType<ISimpleAdapter, SimpleAdapterOne>("one");
container.RegisterType<ISimpleAdapter, SimpleAdapterTwo>("two");
container.RegisterType<ISimpleAdapter, SimpleAdapterThree>("three");
container.RegisterType<ISimpleAdapter, SimpleAdapterFour>("four");
container.RegisterType<ISimpleAdapter, SimpleAdapterFive>("five");
container.RegisterType<ImportMultiple1>();
container.RegisterType<ImportMultiple2>();
container.RegisterType<ImportMultiple3>();
for (int i = 0; i < 1000000000; i++)
{
var importMultiple1 = (ImportMultiple1)container.Resolve(typeof(ImportMultiple1));
var importMultiple2 = (ImportMultiple2)container.Resolve(typeof(ImportMultiple2));
var importMultiple3 = (ImportMultiple3)container.Resolve(typeof(ImportMultiple3));
//var complex1 = (IComplex1)container.Resolve(typeof(IComplex1));
//var complex2 = (IComplex2)container.Resolve(typeof(IComplex2));
//var complex3 = (IComplex3)container.Resolve(typeof(IComplex3));
//container.PrepareType<IFirstService, FirstService>().WithLifetime(new SingletonLifetime()).Register();
//container.PrepareType<ISecondService, SecondService>().WithLifetime(new SingletonLifetime()).Register();
//container.PrepareType<IThirdService, ThirdService>().WithLifetime(new SingletonLifetime()).Register();
//container.RegisterType<ISubObjectOne, SubObjectOne>();
//container.RegisterType<ISubObjectTwo, SubObjectTwo>();
//container.RegisterType<ISubObjectThree, SubObjectThree>();
//container.RegisterType<IComplex1, Complex1>();
//container.RegisterType<IComplex2, Complex2>();
//container.RegisterType<IComplex3, Complex3>();
}
}
Console.Write("Done");
Console.ReadKey();
}
public void Ensure_Good_Constructor_Selected()
{
var container = new StashboxContainer();
container.RegisterAssemblyContaining <ClassA>();
var funcA = container.Resolve <Func <ClassA, InjectedClass> >();
var classA = container.Resolve <ClassA>();
var injectedA = funcA(classA);
var funcB = container.Resolve <Func <ClassB, InjectedClass> >();
var classB = container.Resolve <ClassB>();
var injectedB = funcB(classB);
Assert.Equal(classA, injectedA.ClassA);
Assert.Equal(classB, injectedB.ClassB);
}
public void Ensure_Good_Constructor_Selected_Deeper_In_The_Tree()
{
var container = new StashboxContainer();
container.Register <A>().Register <B>().Register <Subject1>().Register <Subject2>();
var fa = container.Resolve <Func <A, Subject2> >();
var a = container.Resolve <A>();
var instA = fa(a);
var fb = container.Resolve <Func <B, Subject2> >();
var b = container.Resolve <B>();
var instB = fb(b);
Assert.Equal(a, instA.Subject1.A);
Assert.Equal(b, instB.Subject1.B);
}
public void ReMapTests_SingleResolve()
{
IStashboxContainer container = new StashboxContainer();
container.RegisterType<ITest1, Test1>();
var test1 = container.Resolve<ITest1>();
Assert.IsNotNull(test1);
Assert.IsInstanceOfType(test1, typeof(Test1));
container.ReMap<ITest1, Test11>();
var test11 = container.Resolve<ITest1>();
Assert.IsNotNull(test11);
Assert.IsInstanceOfType(test11, typeof(Test11));
}
public void EnumerableTests_Resolve()
{
IStashboxContainer container = new StashboxContainer();
container.RegisterType<ITest1, Test1>();
container.RegisterType<ITest1, Test11>();
container.RegisterType<ITest1, Test12>();
container.RegisterType<ITest2, Test2>("enumerable");
container.RegisterType<ITest2, Test22>("array");
var enumerable = container.Resolve<ITest2>("enumerable");
var array = container.Resolve<ITest2>("array");
var all = container.Resolve<IEnumerable<ITest2>>();
var all2 = container.ResolveAll<ITest2>();
Assert.AreEqual(2, all.Count());
Assert.AreEqual(2, all2.Count());
}
public void LifetimeTests_Resolve()
{
using (IStashboxContainer container = new StashboxContainer())
{
container.PrepareType<ITest1, Test1>().WithLifetime(new SingletonLifetime()).Register();
container.RegisterType<ITest2, Test2>();
container.RegisterType<ITest3, Test3>();
var test1 = container.Resolve<ITest1>();
test1.Name = "test1";
var test2 = container.Resolve<ITest2>();
var test3 = container.Resolve<ITest3>();
Assert.IsNotNull(test1);
Assert.IsNotNull(test2);
Assert.IsNotNull(test3);
}
}
public void ReMapTests_DependencyResolve_Fluent()
{
IStashboxContainer container = new StashboxContainer();
container.RegisterType<ITest1>(typeof(Test1));
container.RegisterType<ITest2, Test2>();
var test2 = container.Resolve<ITest2>();
Assert.IsNotNull(test2.Test1);
Assert.IsInstanceOfType(test2.Test1, typeof(Test1));
container.PrepareType<ITest1>(typeof(Test11)).ReMap();
var test22 = container.Resolve<ITest2>();
Assert.IsNotNull(test22.Test1);
Assert.IsInstanceOfType(test22.Test1, typeof(Test11));
}
public void BuildExtensionManagerTests_AddPostBuildExtension()
{
var post = new Mock<IPostBuildExtension>();
using (var container = new StashboxContainer())
{
container.RegisterExtension(post.Object);
var obj = new object();
container.PrepareType<object>().WithFactory(() => obj).Register();
post.Setup(p => p.PostBuild(obj, obj.GetType(), container.ContainerContext, It.IsAny<ResolutionInfo>(),
It.IsAny<TypeInformation>(), null)).Returns(obj).Verifiable();
var inst = container.Resolve(typeof(object));
post.Verify(p => p.Initialize(container.ContainerContext));
}
post.Verify(p => p.CleanUp());
}
public void OverrideTests_Resolve()
{
IStashboxContainer container = new StashboxContainer();
container.RegisterType<ITest1, Test1>();
container.PrepareType<ITest2, Test2>().WithInjectionParameters(new InjectionParameter { Value = new Test1 { Name = "fakeName" }, Name = "test1" }).Register();
var inst2 = container.Resolve<ITest2>();
Assert.IsInstanceOfType(inst2, typeof(Test2));
Assert.AreEqual("fakeName", inst2.Name);
container.RegisterType<ITest3, Test3>();
var inst1 = container.Resolve<ITest1>();
inst1.Name = "test1";
var inst3 = container.Resolve<ITest3>(overrides: new[] { new TypeOverride(typeof(ITest1), inst1), new TypeOverride(typeof(ITest2), inst2) });
Assert.IsInstanceOfType(inst3, typeof(Test3));
Assert.AreEqual("test1fakeNametest1", inst3.Name);
}
public void EnumerableTests_Parallel_Resolve()
{
IStashboxContainer container = new StashboxContainer();
container.RegisterType<ITest1, Test1>();
container.RegisterType<ITest1, Test11>();
container.RegisterType<ITest1, Test12>();
container.RegisterType<ITest2, Test2>("enumerable");
container.RegisterType<ITest2, Test22>("array");
Parallel.For(0, 50000, (i) =>
{
var enumerable = container.Resolve<ITest2>("enumerable");
var array = container.Resolve<ITest2>("array");
var all = container.Resolve<IEnumerable<ITest2>>();
Assert.AreEqual(2, all.Count());
});
}
public void InjectionMemberTests_BuildUp()
{
using (var container = new StashboxContainer())
{
container.RegisterType<ITest, Test>();
var test1 = new Test1();
container.BuildUp<ITest1>(test1);
var inst = container.Resolve<ITest1>();
Assert.IsNotNull(inst);
Assert.IsNotNull(inst.Test);
Assert.IsInstanceOfType(inst, typeof(Test1));
Assert.IsInstanceOfType(inst.Test, typeof(Test));
Assert.IsNotNull(((Test1)inst).TestFieldProperty);
Assert.IsInstanceOfType(((Test1)inst).TestFieldProperty, typeof(Test));
}
}
public void StandardResolveTests_Resolve()
{
using (IStashboxContainer container = new StashboxContainer())
{
container.RegisterType<ITest1, Test1>();
container.RegisterType<ITest2, Test2>();
container.RegisterType<ITest3, Test3>();
var test3 = container.Resolve<ITest3>();
var test2 = container.Resolve<ITest2>();
var test1 = container.Resolve<ITest1>();
Assert.IsNotNull(test3);
Assert.IsNotNull(test2);
Assert.IsNotNull(test1);
Assert.IsInstanceOfType(test1, typeof(Test1));
Assert.IsInstanceOfType(test2, typeof(Test2));
Assert.IsInstanceOfType(test3, typeof(Test3));
}
}
public void BuildExtensionManagerTests_CreateCopy()
{
var post = new Mock<IRegistrationExtension>();
var post2 = new Mock<IRegistrationExtension>();
using (var container = new StashboxContainer())
{
container.RegisterExtension(post.Object);
post.Setup(p => p.CreateCopy()).Returns(post2.Object).Verifiable();
using (var child = container.CreateChildContainer())
{
child.RegisterInstance(new object());
post2.Verify(p => p.Initialize(child.ContainerContext));
post2.Verify(p => p.OnRegistration(child.ContainerContext,
It.IsAny<RegistrationInfo>(), null));
}
post2.Verify(p => p.CleanUp());
}
post.Verify(p => p.CleanUp());
}
public void AttributeTests_Parallel_Lazy_Resolve()
{
var container = new StashboxContainer();
container.RegisterType<ITest1, Test1>("test1");
container.RegisterType<ITest1, Test11>("test11");
container.RegisterType<ITest1, Test12>("test12");
container.RegisterType<ITest2, Test2>("test2");
container.RegisterType<ITest2, Test22>("test22");
container.RegisterType<ITest3, Test3>();
container.RegisterType<ITest4, Test4>();
container.RegisterType<Test33>();
Parallel.For(0, 50000, (i) =>
{
var test1 = container.Resolve<Lazy<ITest1>>();
var test2 = container.Resolve<Lazy<ITest2>>("test2");
var test3 = container.Resolve<Lazy<ITest3>>();
var test4 = container.Resolve<Lazy<ITest4>>();
var test33 = container.Resolve<Lazy<Test33>>();
Assert.IsNotNull(test1.Value);
Assert.IsNotNull(test2.Value);
Assert.IsNotNull(test3.Value);
Assert.IsNotNull(test4.Value);
Assert.IsTrue(test3.Value.MethodInvoked);
Assert.IsTrue(test4.Value.MethodInvoked);
Assert.IsInstanceOfType(test2.Value.test1, typeof(Test1));
Assert.IsInstanceOfType(test3.Value.test1, typeof(Test11));
Assert.IsInstanceOfType(test3.Value.test2, typeof(Test22));
Assert.IsInstanceOfType(test4.Value.test1.Value, typeof(Test11));
Assert.IsInstanceOfType(test4.Value.test2.Value, typeof(Test22));
});
}
public void AttributeTests_Resolve()
{
var container = new StashboxContainer();
container.RegisterType<ITest1, Test1>("test1");
container.RegisterType<ITest1, Test11>("test11");
container.RegisterType<ITest1, Test12>("test12");
container.RegisterType<ITest2, Test2>("test2");
container.PrepareType<ITest2, Test22>().WithName("test22").Register();
container.RegisterType<ITest3, Test3>();
container.RegisterType<ITest4, Test4>();
container.RegisterType<Test33>();
var test1 = container.Resolve<ITest1>();
var test2 = container.Resolve<ITest2>("test2");
var test3 = container.Resolve<ITest3>();
var test4 = container.Resolve<Lazy<ITest4>>();
var test33 = container.Resolve<Test33>();
Assert.IsNotNull(test1);
Assert.IsNotNull(test2);
Assert.IsNotNull(test3);
Assert.IsNotNull(test33);
Assert.IsNotNull(test4.Value);
Assert.IsTrue(test3.MethodInvoked);
Assert.IsInstanceOfType(test2.test1, typeof(Test1));
Assert.IsInstanceOfType(test3.test1, typeof(Test11));
Assert.IsInstanceOfType(test3.test2, typeof(Test22));
}
public void ConditionalTests_ParentTypeCondition_Third_NonGeneric()
{
var container = new StashboxContainer();
container.RegisterType<ITest1, Test1>();
container.RegisterType<ITest1, Test11>();
container.PrepareType<ITest1, Test12>().WhenDependantIs(typeof(Test2)).Register();
container.RegisterType<ITest2, Test2>();
var test2 = container.Resolve<ITest2>();
Assert.IsInstanceOfType(test2.test1, typeof(Test12));
Assert.IsInstanceOfType(test2.test12, typeof(Test12));
}
public void LifetimeTests_Resolve_Parallel_Lazy()
{
using (IStashboxContainer container = new StashboxContainer())
{
container.PrepareType<ITest1, Test1>().WithLifetime(new SingletonLifetime()).Register();
container.RegisterType<ITest2, Test2>();
container.RegisterType<ITest3, Test3>();
Parallel.For(0, 50000, (i) =>
{
var test1 = container.Resolve<Lazy<ITest1>>();
test1.Value.Name = "test1";
var test2 = container.Resolve<Lazy<ITest2>>();
var test3 = container.Resolve<Lazy<ITest3>>();
Assert.IsNotNull(test1.Value);
Assert.IsNotNull(test2.Value);
Assert.IsNotNull(test3.Value);
});
}
}
