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 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 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 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 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 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 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 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);
});
}
}
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 InjectionMemberTests_Resolve_InjectionParameter()
{
var container = new StashboxContainer();
container.PrepareType<ITest2, Test2>().WithInjectionParameters(new InjectionParameter { Name = "Name", Value = "test" }).Register();
var inst = container.Resolve<ITest2>();
Assert.IsNotNull(inst);
Assert.IsInstanceOfType(inst, typeof(Test2));
Assert.AreEqual("test", inst.Name);
}
public void FactoryBuildUpTests_Resolve_OneParam()
{
using (var container = new StashboxContainer())
{
container.PrepareType<ITest, Test>().WithFactory((a) => new Test((string)a)).Register();
container.RegisterType<ITest1, Test1>();
var inst = container.Resolve<ITest1>(factoryParameters: new[] { "test" });
Assert.IsInstanceOfType(inst.Test, typeof(Test));
Assert.AreEqual("test", inst.Test.Name);
}
}
public void OverrideTests_Resolve_Parallel_Lazy()
{
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<Lazy<ITest2>>();
Assert.IsInstanceOfType(inst2.Value, typeof(Test2));
Assert.AreEqual("fakeName", inst2.Value.Name);
container.RegisterType<ITest3, Test3>();
Parallel.For(0, 50000, (i) =>
{
var inst1 = container.Resolve<Lazy<ITest1>>();
inst1.Value.Name = "test1";
var inst3 = container.Resolve<Lazy<ITest3>>(overrides: new[] { new TypeOverride(typeof(ITest1), inst1.Value), new TypeOverride(typeof(ITest2), inst2.Value) });
Assert.IsInstanceOfType(inst3.Value, typeof(Test3));
Assert.AreEqual("test1fakeNametest1", inst3.Value.Name);
Assert.IsTrue(inst3.Value.MethodInvoked);
});
}
