public AddFactory ( |
||
serviceType | The service type to associate with the factory | |
additionalParameterTypes | IEnumerable |
The list of additional parameters that this factory type will support. |
factory | IFactory | The |
return | void |
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 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 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 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 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 ContainerMustSupportNamedGenericAddFactoryMethod() { var container = new ServiceContainer(); var mockFactory = new Mock<IFactory<ISerializable>>(); var mockService = new Mock<ISerializable>(); container.AddFactory("MyService", mockFactory.Object); mockFactory.Expect(f => f.CreateInstance(It.Is<IFactoryRequest>(request => request.Container == container))) .Returns(mockService.Object); Assert.IsNotNull(container.GetService<ISerializable>("MyService")); }
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 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 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 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 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(); }