public void ShouldBeAbleToLoadSampleAssemblyWithoutRunningIntoConstructorNotFoundException()
{
var loader = new DependencyMapLoader();
var map = loader.LoadFromBaseDirectory("SampleAssembly.dll");
var container = map.CreateContainer();
var result = container.GetInstance<object>("Sample");
Assert.AreEqual(42, result);
}
public void ShouldBeAbleToGetAServiceThatImplementsSimpleProperties()
{
var loader = new DependencyMapLoader();
var map = loader.LoadFromBaseDirectory("SampleAssembly.dll");
//var map = new DependencyMap();
//map.AddService<IFalseDependency>(x=>new SampleFalseDependency());
var container = map.CreateContainer();
var result = container.GetInstance<IFalseDependency>();
Assert.IsNotNull(result,"The container did not create IFalseDependency instance");
}
public void ShouldLoadAllImplementationsAndInterfaces()
{
var assembly = typeof(IDBConnection).Assembly;
var loader = new DependencyMapLoader();
var map = loader.LoadFrom(assembly);
var container = map.CreateContainer();
var testRepo = container.GetInstance<ITestRepo>();
Assert.IsNotNull(testRepo);
}
public void ShouldBeAbleToAutomaticallyInjectBaseGenericInterfaceTypes()
{
var loader = new DependencyMapLoader();
var map = loader.LoadFromBaseDirectory("Sample*.dll");
map.AddService<IFoo<int>, SampleGenericImplementation>();
var dependencies = map.Dependencies;
var container = map.CreateContainer();
Assert.IsTrue(container.Contains(typeof(IBaz<int>), "SampleGenericImplementation"));
Assert.IsTrue(container.Contains(typeof(IFoo<int>), "SampleGenericImplementation"));
}
public void ShouldLoadAndCreateContainerFromBaseDirectory()
{
var loader = new DependencyMapLoader();
var map = loader.LoadFromBaseDirectory("*.UnitTests.dll");
var container = map.CreateContainer();
Assert.IsNotNull(container);
var vehicle = container.GetInstance<IVehicle>();
Assert.IsNotNull(vehicle);
}
public void ShouldBeAbleToFilterLoadedServicesUsingASinglePredicate()
{
Predicate<IServiceInfo> serviceFilter = service => service.ServiceType != typeof(IVehicle);
var loader = new DependencyMapLoader();
loader.ServiceFilter = serviceFilter;
var map = loader.LoadFrom(AppDomain.CurrentDomain.BaseDirectory, "*.UnitTests.dll");
var container = map.CreateContainer();
Assert.IsNotNull(container);
// There should be no IVehicle container instances
// in this container since the IVehicle service has been filtered
// out of the container
var vehicle = container.GetInstance<IVehicle>();
Assert.IsNull(vehicle);
}
public void ShouldBeAbleToLoadEnumerableServicesByDefault()
{
var loader = new DependencyMapLoader();
loader.ServiceFilter = info => !string.IsNullOrEmpty(info.ServiceName) && info.ServiceName.StartsWith("Baz")
&& info.ServiceType == typeof(IBaz<int>) || info.ServiceType == typeof(IFizz);
var map = loader.LoadFrom(typeof(IFoo<>).Assembly);
var container = map.CreateContainer();
Assert.IsNotNull(container);
var fizz = container.GetInstance<IFizz>();
Assert.IsNotNull(fizz);
Assert.AreEqual(3, fizz.Services.Count());
var services = fizz.Services.ToArray();
Assert.IsInstanceOfType(typeof(Baz1), services[0]);
Assert.IsInstanceOfType(typeof(Baz2), services[1]);
Assert.IsInstanceOfType(typeof(Baz3), services[2]);
}
/// <summary>
/// Compiles the target IOC container.
/// </summary>
/// <returns>Returns <c>true</c> if the operation succeeded. Otherwise, it will return <c>false</c>.</returns>
public override bool Execute()
{
bool result = true;
try
{
string targetPath = GetTargetPath(TargetAssemblies);
targetPath = string.IsNullOrEmpty(targetPath) ? Environment.CurrentDirectory : targetPath;
targetPath = Path.GetDirectoryName(targetPath);
var targetFiles = Path.GetFileName(TargetAssemblies);
var loader = new DependencyMapLoader();
var dependencyMap = loader.LoadFrom(targetPath, targetFiles);
var typeName = "MicroContainer" ?? TypeName;
var namespaceName = "Hiro.Containers" ?? NamespaceName;
var assemblyName = "Hiro.CompiledContainers" ?? AssemblyName;
var compiler = new ContainerCompiler();
var compiledAssembly = compiler.Compile(typeName, namespaceName, assemblyName, dependencyMap);
Console.WriteLine("Compiling {0}", OutputAssemblyFileName);
compiledAssembly.Write(OutputAssemblyFileName);
}
catch (Exception ex)
{
result = false;
Log.LogError(string.Format("Exception thrown: {0}", ex));
}
return result;
}
public void should_create_either_both_empty_or_both_equivalent_and_not_null()
{
var map1 = new DependencyMapLoader().LoadFrom(typeof(ISomeService).Assembly);
var container1 = map1.CreateContainer();
var service1 = container1.GetInstance<ISomeService>();
var map2 = new DependencyMap();
map2.AddService<ISomeService,SomeService>();
var container2 = map2.CreateContainer();
var service2 = container2.GetInstance<ISomeService>();
Assert.IsFalse(service2==null||service1==null,"At least one service is null 1:{0} 2:{1}",service1,service2);
Assert.AreEqual(service1.GetType(),service2.GetType(),"types are not the same");
}
public void ShouldReturnNullWhenTryingToInstantiateAnIncompleteDependency()
{
var loader = new DependencyMapLoader();
var map = loader.LoadFromBaseDirectory("SampleAssembly.dll");
var container = map.CreateContainer();
var result = container.GetInstance<IMissing>();
Assert.IsNull(result,"The container created an incomplete instance");
}
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 Type[0]);
resolver.Expect(r => r.GetDefaultService(It.IsAny<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 ShouldLoadAndCreateContainerFromSingleAssembly()
{
var loader = new DependencyMapLoader();
var map = loader.LoadFrom(typeof(IPerson).Assembly);
var container = map.CreateContainer();
Assert.IsNotNull(container);
var vehicle = container.GetInstance<IVehicle>();
Assert.IsNotNull(vehicle);
}
