public void ReuseSameContainerManagerFromExternalContainer()
{
IWindsorContainer windsorContainer = new WindsorContainer();
windsorContainer.Register(Component.For <IDependantClass>().ImplementedBy <DependantClass2>());
string containerKey = Guid.NewGuid().ToString();
IContainerManager containerManager =
new ContainerManager(new WindsorContainerAdapter(containerKey, windsorContainer));
IDependantClass dependantClass = containerManager.Resolve <IDependantClass>();
Assert.IsNotNull(dependantClass);
IContainerManager containerManager2 = new ContainerManager("New Container");
IDependantClass dependantClass2 = containerManager2.Resolve <IDependantClass>();
Assert.IsNotNull(dependantClass2);
IContainerManager containerManager3 = new ContainerManager("New Container 1");
// Show its not random
IDependantClass dependantClass3 = containerManager3.TryResolve <IDependantClass>();
Assert.IsNull(dependantClass3);
}
protected void ResolveComponentByName(Func <IContainerManager> containerManagerFunc)
{
IContainerManager containerManager = containerManagerFunc();
IDependantClass dependency = containerManager.Resolve <IDependantClass>("DependentClass2");
Assert.IsNotNull(dependency);
Assert.AreEqual(typeof(DependantClass2), dependency.GetType());
}
protected void ResolveComponentWithNameAndParameters(Func <IContainerManager> containerManagerFunc)
{
IContainerManager containerManager = containerManagerFunc();
IDependantClass dependency = containerManager.Resolve <IDependantClass>("DependentClass2", new Dictionary <string, object>());
Assert.IsNotNull(dependency);
Assert.AreEqual(typeof(DependantClass2), dependency.GetType());
}
protected void CanRegisterDefaultTypeComponent(Func <IContainerAdapter> adapterFunc)
{
IContainerManager containerManager = new ContainerManager(adapterFunc());
containerManager.Adapter.Register <IDependantClass, DependantClass>();
IDependantClass dependantClass1 = containerManager.Resolve <IDependantClass>();
IDependantClass dependantClass2 = containerManager.Resolve <IDependantClass>();
Assert.AreNotEqual(dependantClass1, dependantClass2);
}
protected void CanRegisterSingletonTypeComponent(Func <IContainerAdapter> adapterFunc)
{
IContainerManager containerManager = new ContainerManager(adapterFunc());
containerManager.Adapter.Register <IDependantClass, DependantClass>(LifetimeScope.Singleton);
IDependantClass dependantClass1 = containerManager.Resolve <IDependantClass>();
IDependantClass dependantClass2 = containerManager.Resolve <IDependantClass>();
Assert.AreEqual(dependantClass1, dependantClass2);
}
protected void CanRegisterNamedTransientTypeComponent(Func <IContainerAdapter> adapterFunc)
{
IContainerManager containerManager = new ContainerManager(adapterFunc());
containerManager.Adapter.Register <IDependantClass, DependantClass>(LifetimeScope.Transient, "fred");
IDependantClass dependantClass1 = containerManager.Resolve <IDependantClass>("fred");
IDependantClass dependantClass2 = containerManager.Resolve <IDependantClass>("fred");
Assert.AreNotEqual(dependantClass1, dependantClass2);
}
/// <summary>
/// Test that trying to resolve a component that has been registered returns that component
/// </summary>
public void TestTryResolvesSuccessful(Func <IContainerManager> containerManagerFunc)
{
IContainerManager manager = containerManagerFunc();
Assert.IsNotNull(manager);
IDependantClass instance = manager.TryResolve <IDependantClass>();
Assert.IsNotNull(instance);
}
protected void CanRegisterNamedRawType(Func <IContainerAdapter> adapterFunc)
{
IContainerManager containerManager = new ContainerManager(adapterFunc());
Assert.IsNull(containerManager.TryResolve(typeof(IDependantClass), "fred"));
containerManager.Adapter.Register <IDependantClass, DependantClass>("fred");
IDependantClass dependantClass = containerManager.Resolve(typeof(IDependantClass), "fred") as IDependantClass;
Assert.IsNotNull(dependantClass);
}
protected void TestSimpleRegistration(Func <IContainerAdapter> adapterFunc)
{
IContainerManager containerManager = new ContainerManager(adapterFunc());
Assert.IsNull(containerManager.TryResolve <IDependantClass>());
containerManager.Adapter.Register <IDependantClass, DependantClass>();
IDependantClass dependantClass = containerManager.Resolve <IDependantClass>();
Assert.IsNotNull(dependantClass);
}
public void UseExternalContainer()
{
ContainerBuilder builder = new ContainerBuilder();
builder.RegisterType <DependantClass2>().As <IDependantClass>();
ContainerManager containerManager = new ContainerManager(new AutofacContainerAdapter(builder.Build()));
IDependantClass dependency = containerManager.Resolve <IDependantClass>();
Assert.IsNotNull(dependency);
Assert.AreEqual(typeof(DependantClass2), dependency.GetType());
}
protected void CanRegisterFluentDefaultTypeComponent(Func <IContainerAdapter> adapterFunc)
{
IContainerManager containerManager = new ContainerManager(adapterFunc());
IComponentRegistration registration = containerManager.Adapter.CreateComponentRegistration <ComponentRegistration>();
registration = registration.Register <IDependantClass>().As <DependantClass>();
containerManager.Adapter.Register(registration);
IDependantClass dependantClass1 = containerManager.Resolve <IDependantClass>();
IDependantClass dependantClass2 = containerManager.Resolve <IDependantClass>();
Assert.AreNotEqual(dependantClass1, dependantClass2);
}
public void UseExternalContainer()
{
IUnityContainer container = new UnityContainer();
container.RegisterType(typeof(IDependantClass), typeof(DependantClass));
string containerKey = Guid.NewGuid().ToString();
IContainerManager containerManager = new ContainerManager(new UnityContainerAdapter(containerKey, container));
IDependantClass dependency = containerManager.Resolve <IDependantClass>();
Assert.IsNotNull(dependency);
Assert.AreEqual(typeof(DependantClass), dependency.GetType());
}
public void UseExternalContainer()
{
IWindsorContainer container = new WindsorContainer();
container.Register(Component.For <IDependantClass>().ImplementedBy <DependantClass>());
string containerKey = Guid.NewGuid().ToString();
IContainerManager containerManager = new ContainerManager(new WindsorContainerAdapter(containerKey, container));
IDependantClass dependency = containerManager.Resolve <IDependantClass>();
Assert.IsNotNull(dependency);
Assert.AreEqual(typeof(DependantClass), dependency.GetType());
}
public void UseExternalContainer()
{
IContainer container = new Container();
container.Configure(x => x.For <IDependantClass>().Use <DependantClass>());
string containerKey = Guid.NewGuid().ToString();
ContainerManager containerManager = new ContainerManager(new StructureMapContainerAdapter(containerKey, container));
IDependantClass dependency = containerManager.Resolve <IDependantClass>();
Assert.IsNotNull(dependency);
Assert.AreEqual(typeof(DependantClass), dependency.GetType());
}
protected void CanRegisterInstanceByName(Func <IContainerAdapter> adapterFunc)
{
IContainerManager containerManager = new ContainerManager(adapterFunc());
Assert.IsNull(containerManager.TryResolve <IDependantClass>("fred"));
var dependantClassToRegister = new DependantClass2();
containerManager.Adapter.Register <IDependantClass>("fred", dependantClassToRegister);
IDependantClass dependantClass = containerManager.Resolve(typeof(IDependantClass), "fred") as IDependantClass;
Assert.AreEqual(dependantClassToRegister, dependantClass);
}
protected void TestMultipleSimpleRegistrationsResolvesFirst(Func <IContainerAdapter> adapterFunc)
{
IContainerManager containerManager = new ContainerManager(adapterFunc());
Assert.IsNull(containerManager.TryResolve <IDependantClass>());
containerManager.Adapter.Register <IDependantClass, DependantClass2>();
containerManager.Adapter.Register <IDependantClass, DependantClass>();
IDependantClass dependantClass = containerManager.Resolve <IDependantClass>();
Assert.IsNotNull(dependantClass);
Assert.AreEqual(typeof(DependantClass2), dependantClass.GetType());
}
public void StartContainerManually()
{
IWindsorContainer container = new WindsorContainer();
string containerKey = Guid.NewGuid().ToString();
var containerManager = new ContainerManager(new WindsorContainerAdapter(containerKey, container));
Assert.IsNull(containerManager.Resolve <IDependantClass>());
containerManager.Adapter.Register <IDependantClass, DependantClass>();
IDependantClass dependantClass = containerManager.Resolve <IDependantClass>();
Assert.IsNotNull(dependantClass);
}
public void ResolveItemByInterfaceOnly()
{
ContainerManager containerManager = new ContainerManager(TestConstants.WindsorContainerName);
IDependantClass dependency = containerManager.Resolve <IDependantClass>();
Assert.IsNotNull(dependency);
Assert.AreEqual(typeof(DependantClass), dependency.GetType());
ContainerManager unityContainerManager = new ContainerManager(TestConstants.UnityContainerName);
IDependantClass unityDependency = unityContainerManager.Resolve <IDependantClass>();
Assert.AreEqual(typeof(DependantClass), unityDependency.GetType());
}
protected void CanRegisterBasicType(Func <IContainerAdapter> adapterFunc)
{
IContainerManager containerManager = new ContainerManager(adapterFunc());
Assert.IsNull(containerManager.TryResolve <IDependantClass>());
DependantClass instanceDependantClass = new DependantClass();
containerManager.Adapter.Register <IDependantClass>(instanceDependantClass);
IDependantClass dependantClass = containerManager.Resolve <IDependantClass>();
Assert.AreEqual(instanceDependantClass, dependantClass);
}
protected void CanRegisterGroup(Func <IContainerAdapter> adapterFunc)
{
IContainerManager containerManager = new ContainerManager(adapterFunc());
Assert.IsNull(containerManager.TryResolve <IDependantClass>());
IContainerManagerGroupRegistration groupRegistration = new TestGroupRegistration();
containerManager.Adapter.RegisterGroup(groupRegistration);
IDependantClass dependantClass = containerManager.Resolve <IDependantClass>();
Assert.IsNotNull(dependantClass);
Assert.AreEqual(typeof(DependantClass), dependantClass.GetType());
}
protected void CanRegisterByName(Func <IContainerAdapter> adapterFunc)
{
IContainerManager containerManager = new ContainerManager(adapterFunc());
const string dependencyName = "dependantReg";
containerManager.Adapter.Register <IDependantClass, DependantClass>();
containerManager.Adapter.Register <IDependantClass, DependantClass2>(dependencyName);
IDependantClass dependantClass = containerManager.Resolve <IDependantClass>();
Assert.IsNotNull(dependantClass);
IDependantClass dependantClass2 = containerManager.Resolve <IDependantClass>(dependencyName);
Assert.IsNotNull(dependantClass2);
Assert.AreEqual(typeof(DependantClass2), dependantClass2.GetType());
Assert.AreEqual(TestConstants.DependantClassName, dependantClass.Name);
Assert.AreEqual(TestConstants.DependantClass2Name, dependantClass2.Name);
}
