public void ShouldLoadServicesUsingTheGivenServiceLoaderAndAssemblyLoaderAndServiceResolverInstances() { var serviceLoader = new Mock <IServiceLoader>(); var resolver = new Mock <IDefaultServiceResolver>(); var typeLoader = new Mock <ITypeLoader>(); var assembly = typeof(IPerson).Assembly; var assemblies = new Assembly[] { assembly }; var serviceList = new List <IServiceInfo>(); IEnumerable <IServiceInfo> services = serviceList; var defaultService = new ServiceInfo(typeof(IVehicle), typeof(Vehicle), "Vehicle"); serviceList.Add(new ServiceInfo(typeof(IVehicle), typeof(Truck), "Truck")); serviceList.Add(defaultService); typeLoader.Expect(l => l.LoadTypes(It.IsAny <Assembly>())).Returns(new System.Type[0]); resolver.Expect(r => r.GetDefaultService(It.IsAny <System.Type>(), It.IsAny <IEnumerable <IServiceInfo> >())).Returns(defaultService); serviceLoader.Expect(s => s.Load(assembly)).Returns(services); var loader = new DependencyMapLoader(typeLoader.Object, serviceLoader.Object, resolver.Object); DependencyMap map = loader.LoadFrom(assemblies); typeLoader.VerifyAll(); resolver.VerifyAll(); serviceLoader.VerifyAll(); // Make sure the services are loaded into the dependency map Assert.IsTrue(map.Contains(new Dependency(typeof(IVehicle), "Vehicle"))); Assert.IsTrue(map.Contains(new Dependency(typeof(IVehicle), "Truck"))); Assert.IsTrue(map.Contains(new Dependency(typeof(IVehicle)))); }
public void ShouldBeAbleToRegisterAnonymousServicesWithDependencyMapUsingGenerics() { var dependencyMap = new DependencyMap(); dependencyMap.AddService<IVehicle, Vehicle>(); Assert.IsTrue(dependencyMap.Contains(new Dependency(typeof(IVehicle)))); Assert.IsTrue(dependencyMap.Contains(typeof(IVehicle))); }
public void ShouldBeAbleToRegisterAnonymousSingletonServicesWithDependencyMap() { var dependencyMap = new DependencyMap(); dependencyMap.AddSingletonService <IVehicle, Vehicle>(); Assert.IsTrue(dependencyMap.Contains(new Dependency(typeof(IVehicle)))); Assert.IsTrue(dependencyMap.Contains(typeof(IVehicle))); }
public void ShouldBeAbleToReturnAllAvailableImplementationsForADependency() { var numberOfImplementations = 5; var implementations = Enumerable.Range(0, numberOfImplementations) .Select(_ => A.Fake <IImplementation>()).ToArray(); var dependency = new Dependency(typeof(IEnumerable <string>)); var map = new DependencyMap(); for (var i = 0; i < numberOfImplementations; i++) { var implementation = implementations[i]; map.AddService(dependency, implementation); } Assert.True(map.Contains(dependency)); Assert.Contains(dependency, map.Dependencies); var results = map.GetImplementations(dependency, false).ToArray(); for (var i = 0; i < numberOfImplementations; i++) { Assert.Contains(implementations[i], results); } }
public void ShouldBeAbleToAddMultipleServices() { var numberOfDependencies = 5; var implementations = Enumerable.Range(0, numberOfDependencies) .Select(_ => A.Fake <IImplementation>()).ToArray(); var dependencies = Enumerable.Range(0, numberOfDependencies) .Select(_ => A.Fake <IDependency>()).ToArray(); var map = new DependencyMap(); for (var i = 0; i < numberOfDependencies; i++) { var dependency = dependencies[i]; var implementation = implementations[i]; map.AddService(dependency, implementation); } for (var i = 0; i < numberOfDependencies; i++) { var dependency = dependencies[i]; Assert.True(map.Contains(dependency)); Assert.Contains(dependency, map.Dependencies); } }
public void ShouldBeAbleToRegisterNamedServicesWithDependencyMapUsingGenerics() { var serviceName = "MyService"; var dependencyMap = new DependencyMap(); dependencyMap.AddService <IVehicle, Vehicle>(serviceName); Assert.IsTrue(dependencyMap.Contains(typeof(IVehicle), serviceName)); }
public void ShouldBeAbleToAddItemsToDependencyMap() { var ctor = typeof(Vehicle).GetConstructor(new Type[0]); var dependency = new Dependency(typeof(IVehicle), string.Empty); var constructorImplementation = new ConstructorCall(ctor); var dependencyMap = new DependencyMap(); dependencyMap.AddService(dependency, constructorImplementation); Assert.IsTrue(dependencyMap.Contains(dependency)); }
public void ShouldLoadSampleModuleFromGivenDirectory() { var map = new DependencyMap(); var loader = new ModuleLoader(map); var targetDirectory = Path.GetDirectoryName(typeof(SampleModule).Assembly.Location); loader.LoadModulesFrom(targetDirectory, "*.dll"); Assert.IsTrue(map.Contains(typeof(IList <int>))); }
public void ShouldLoadSampleModule() { var map = new DependencyMap(); var sampleModule = new SampleModule(); var loader = new ModuleLoader(map); loader.LoadModule(sampleModule); Assert.IsTrue(sampleModule.Invoked); Assert.IsTrue(map.Contains(typeof(IList <int>))); }
/// <summary> /// Adds a named service to the dependency map. /// </summary> /// <remarks>This service will be created once per web session.</remarks> /// <param name="map">The target dependency map.</param> /// <param name="serviceName">The service name.</param> /// <param name="serviceType">The service type.</param> /// <param name="implementingType">The implementing type.</param> public static void AddPerSessionService(this DependencyMap map, string serviceName, System.Type serviceType, System.Type implementingType) { // Add the SessionCache by default if (!map.Contains(typeof(ICache))) { map.AddService <ICache, SessionCache>(); } // Add the HttpReferenceTracker by default if (!map.Contains(typeof(IHttpReferenceTracker))) { map.AddService <IHttpReferenceTracker, HttpReferenceTracker>(); } // The cached instantiation class will use the cache in the container // to cache service instances var dependency = new Dependency(serviceType, serviceName); var implementation = new CachedInstantiation(new TransientType(implementingType, map, new ConstructorResolver())); map.AddService(dependency, implementation); }
public void ShouldBeAbleToReturnAllAvailableImplementationsForADependencyExceptForTheIncompleteDependencies() { var numberOfImplementations = 5; var numberOfIncompleteImplementations = 3; IEnumerable <IImplementation> CreateImplementations(int numberOfImplementationsToCreate, bool isCompleted) { var incompleteDependencies = isCompleted ? Enumerable.Empty <IDependency>() : new[] { A.Fake <IDependency>() }; return(Enumerable.Range(0, numberOfImplementationsToCreate) .Select(_ => { var currentImplementation = A.Fake <IImplementation>(); A.CallTo(() => currentImplementation.GetMissingDependencies(A <IDependencyMap> .Ignored)) .Returns(incompleteDependencies); return currentImplementation; }).ToArray()); } var implementations = new List <IImplementation>(); implementations.AddRange(CreateImplementations(numberOfImplementations, true)); var incompleteImplementations = CreateImplementations(numberOfIncompleteImplementations, false) .ToArray(); implementations.AddRange(incompleteImplementations); var dependency = new Dependency(typeof(IEnumerable <string>)); var map = new DependencyMap(); foreach (var implementation in implementations) { map.AddService(dependency, implementation); } Assert.True(map.Contains(dependency)); Assert.Contains(dependency, map.Dependencies); var results = map.GetImplementations(dependency, false).ToArray(); for (var i = 0; i < numberOfImplementations; i++) { Assert.Contains(implementations[i], results); } foreach (var implementation in incompleteImplementations) { Assert.DoesNotContain(implementation, results); } }
public void ShouldBeAbleToAddService() { var dependency = new Dependency(typeof(IList <string>)); var implementation = A.Fake <IImplementation>(); var map = new DependencyMap(); map.AddService(dependency, implementation); Assert.True(map.Contains(dependency)); Assert.Contains(dependency, map.Dependencies); }
public void ShouldBeAbleToRegisterNamedServicesWithDependencyMap() { var serviceName = "MyService"; var dependencyMap = new DependencyMap(); dependencyMap.AddService<IVehicle, Vehicle>(serviceName); Assert.IsTrue(dependencyMap.Contains(typeof(IVehicle), serviceName)); }
// enumerate /// <summary> /// Determines whether this instance has registered. /// </summary> /// <typeparam name="TService">The type of the service.</typeparam> /// <returns> /// <c>true</c> if this instance has registered; otherwise, <c>false</c>. /// </returns> public bool HasRegistered <TService>() { return(_builder.Contains(typeof(TService))); }