public void ServicesCreatedFromCustomOpenGenericFactoryMustInvokeIInitialize()
{
var mockFactory = new Mock <IFactory>();
var serviceInstance = new SampleGenericImplementation <int>();
mockFactory.Expect(f => f.CreateInstance(It.IsAny <IFactoryRequest>()))
.Returns(serviceInstance);
var container = new ServiceContainer();
container.LoadFrom(AppDomain.CurrentDomain.BaseDirectory, "LinFu*.dll");
container.AddFactory("MyService", typeof(ISampleGenericService <>), mockFactory.Object);
var result = container.GetService <ISampleGenericService <int> >("MyService");
bool areSame = ReferenceEquals(serviceInstance, result);
Assert.AreSame(serviceInstance, result);
// Make sure that the IInitialize instance is called
// on the sample class
Assert.IsTrue(serviceInstance.Called);
mockFactory.VerifyAll();
}
public void ContainerMustSupportGenericAddFactoryMethod()
{
var container = new ServiceContainer();
var mockFactory = new Mock <IFactory <ISerializable> >();
var mockService = new Mock <ISerializable>();
container.AddFactory(mockFactory.Object);
mockFactory.Expect(f => f.CreateInstance(It.Is <IFactoryRequest>(request => request.Container == container))).Returns(mockService.Object);
Assert.IsNotNull(container.GetService <ISerializable>());
}
public void ContainerMustHoldAnonymousFactoryInstance()
{
var mockFactory = new Mock <IFactory>();
var container = new ServiceContainer();
// Give it a random service interface type
Type serviceType = typeof(IDisposable);
// Manually add the factory instance
container.AddFactory(serviceType, mockFactory.Object);
Assert.IsTrue(container.Contains(serviceType), "The container needs to have a factory for service type '{0}'", serviceType);
}
public void ContainerMustSupportGenericGetServiceMethod()
{
var mockService = new Mock <ISerializable>();
var mockFactory = new Mock <IFactory>();
var container = new ServiceContainer();
container.AddFactory(typeof(ISerializable), mockFactory.Object);
container.AddFactory("MyService", typeof(ISerializable), mockFactory.Object);
// Return the mock ISerializable instance
mockFactory.Expect(f => f.CreateInstance(
It.Is <IFactoryRequest>(request => request.Container == container &&
request.ServiceType == typeof(ISerializable)))).Returns(mockService.Object);
// Test the syntax
var result = container.GetService <ISerializable>();
Assert.AreSame(mockService.Object, result);
result = container.GetService <ISerializable>("MyService");
Assert.AreSame(mockService.Object, result);
}
public void ContainerMustAllowInjectingCustomFactoriesForOpenGenericTypeDefinitions()
{
var container = new ServiceContainer();
var factory = new SampleOpenGenericFactory();
container.AddFactory(typeof(ISampleGenericService <>), factory);
// The container must report that it *can* create
// the generic service type
Assert.IsTrue(container.Contains(typeof(ISampleGenericService <int>)));
var result = container.GetService <ISampleGenericService <int> >();
Assert.IsNotNull(result);
Assert.IsTrue(result.GetType() == typeof(SampleGenericImplementation <int>));
}
public void ContainerMustUseUnnamedContainsMethodIfNameIsNull()
{
var mockFactory = new Mock <IFactory>();
var mockService = new Mock <ISerializable>();
var container = new ServiceContainer();
Type serviceType = typeof(ISerializable);
// Use unnamed AddFactory method
container.AddFactory(serviceType, mockFactory.Object);
// The container should use the
// IContainer.Contains(Type) method instead of the
// IContainer.Contains(string, Type) method if the
// service name is blank
Assert.IsTrue(container.Contains(null, typeof(ISerializable)));
}
public void ContainerMustUseUnnamedGetServiceMethodIfNameIsNull()
{
var mockFactory = new Mock <IFactory>();
var mockService = new Mock <ISerializable>();
var container = new ServiceContainer();
Type serviceType = typeof(ISerializable);
mockFactory.Expect(f => f.CreateInstance(It.Is <IFactoryRequest>(request => request.ServiceType == serviceType)))
.Returns(mockService.Object);
container.AddFactory(serviceType, mockFactory.Object);
object result = container.GetService(null, serviceType);
Assert.AreSame(mockService.Object, result);
}
public void ContainerMustHoldNamedFactoryInstance()
{
var mockFactory = new Mock <IFactory>();
var container = new ServiceContainer();
// Randomly assign an interface type
// NOTE: The actual interface type doesn't matter
Type serviceType = typeof(ISerializable);
container.AddFactory("MyService", serviceType, mockFactory.Object);
Assert.IsTrue(container.Contains("MyService", serviceType), "The container is supposed to contain a service named 'MyService'");
var instance = new object();
mockFactory.Expect(f => f.CreateInstance(
It.Is <IFactoryRequest>(request => request.ServiceName == "MyService" && request.ServiceType == serviceType)))
.Returns(instance);
Assert.AreSame(instance, container.GetService("MyService", serviceType));
}
public void ContainerMustInjectFactoryInstances()
{
var mockFactory = new Mock <IFactory <ISampleService> >();
mockFactory.Expect(f => f.CreateInstance(It.IsAny <IFactoryRequest>())).Returns(new SampleClass());
var container = new ServiceContainer();
container.AddFactory(mockFactory.Object);
var instance =
(SampleClassWithFactoryDependency)container.AutoCreate(typeof(SampleClassWithFactoryDependency));
Assert.IsNotNull(instance);
IFactory <ISampleService> factory = instance.Factory;
factory.CreateInstance(null);
mockFactory.VerifyAll();
}
public void ContainerMustReturnServiceInstance()
{
var mockFactory = new Mock <IFactory>();
var container = new ServiceContainer();
Type serviceType = typeof(ISerializable);
var instance = new object();
container.AddFactory(serviceType, mockFactory.Object);
// The container must call the IFactory.CreateInstance method
mockFactory.Expect(f => f.CreateInstance(It.Is <IFactoryRequest>(request => request.ServiceType == serviceType &&
request.Container == container))).Returns(instance);
object result = container.GetService(serviceType);
Assert.IsNotNull(result, "The container failed to return the given service instance");
Assert.AreSame(instance, result, "The service instance returned does not match the given instance");
mockFactory.VerifyAll();
}
public void ContainerMustUseUnnamedAddFactoryMethodIfNameIsNull()
{
var mockFactory = new Mock <IFactory>();
var mockService = new Mock <ISerializable>();
var container = new ServiceContainer();
Type serviceType = typeof(ISerializable);
// Add the service using a null name;
// the container should register this factory
// as if it had no name
container.AddFactory(null, serviceType, mockFactory.Object);
mockFactory.Expect(f => f.CreateInstance(
It.Is <IFactoryRequest>(request => request.Container == container &&
request.ServiceType == serviceType))).Returns(mockService.Object);
// Verify the result
var result = container.GetService <ISerializable>();
Assert.AreSame(mockService.Object, result);
}
public void ContainerMustCallIInitializeOnServicesCreatedFromCustomFactory()
{
var mockFactory = new Mock <IFactory>();
var mockInitialize = new Mock <IInitialize>();
mockFactory.Expect(f => f.CreateInstance(It.IsAny <IFactoryRequest>()))
.Returns(mockInitialize.Object);
// The IInitialize instance must be called once it
// leaves the custom factory
mockInitialize.Expect(i => i.Initialize(It.IsAny <IServiceContainer>()));
var container = new ServiceContainer();
container.LoadFrom(AppDomain.CurrentDomain.BaseDirectory, "LinFu*.dll");
container.AddFactory(typeof(IInitialize), mockFactory.Object);
var result = container.GetService <IInitialize>();
mockFactory.VerifyAll();
mockInitialize.VerifyAll();
}
public void ContainerMustReturnServiceInstance()
{
var mockFactory = new Mock <IFactory>();
var container = new ServiceContainer();
var serviceType = typeof(ISerializable);
var instance = new object();
container.AddFactory(serviceType, mockFactory.Object);
// The container must call the IFactory.CreateInstance method
mockFactory.Expect(
f => f.CreateInstance(It.Is <IFactoryRequest>(request => request.ServiceType == serviceType &&
request.Container == container))).Returns(
instance);
var result = container.GetService(serviceType);
Assert.NotNull(result);
Assert.Same(instance, result);
mockFactory.VerifyAll();
}
