public void RegisterInstanceIsFluent()
{
IMicroIocContainer iocContainer = new MicroIocContainer();
var newContainer = iocContainer.RegisterInstance <IFoo>(new Foo());
Assert.AreSame(iocContainer, newContainer);
}
public void GenericTryResolveUnregisteredInterfaceReturnsNull()
{
IMicroIocContainer iocContainer = new MicroIocContainer();
var instance = iocContainer.TryResolve <IFoo>();
Assert.IsNull(instance, "Instance should be null");
}
public void CanRegisterByType()
{
IMicroIocContainer iocContainer = new MicroIocContainer();
var newContainer = iocContainer.Register <IFoo>(typeof(Foo));
Assert.AreSame(iocContainer, newContainer);
}
public void CanRegisterByType()
{
IMicroIocContainer iocContainer = new MicroIocContainer();
var newContainer = iocContainer.Register<IFoo>(typeof(Foo));
Assert.AreSame(iocContainer, newContainer);
}
public void RegisterIsFluent()
{
IMicroIocContainer iocContainer = new MicroIocContainer();
var newContainer = iocContainer.Register <IFoo, Foo>();
Assert.AreSame(iocContainer, newContainer);
}
public void TryResolveUnregisteredInterfaceWithKeyReturnsNull()
{
IMicroIocContainer iocContainer = new MicroIocContainer();
var instance = iocContainer.TryResolve(typeof(IFoo), "SomeKey");
Assert.IsNull(instance, "Instance should be null");
}
public void ContainerCanResolveUnregisteredConcreteTypes()
{
var iocContainer = new MicroIocContainer();
var instance = iocContainer.Resolve <Foo>();
Assert.IsNotNull(instance);
Assert.IsInstanceOfType(instance, typeof(Foo));
}
public void ResoveCreatesItemOfRequiredType()
{
var iocContainer = new MicroIocContainer()
.Register <IFoo, Foo>();
var instance = iocContainer.Resolve <IFoo>();
Assert.IsInstanceOfType(instance, typeof(Foo));
}
public void GenericTryResolveRegisteredInterfaceWithInvalidKeyReturnsNull()
{
var iocContainer = new MicroIocContainer()
.Register <IFoo, Foo>();
var instance = iocContainer.TryResolve <IFoo>("SomeKey");
Assert.IsNull(instance, "Instance should be null");
}
public void ConfigurationIsFluent()
{
var container = new MicroIocContainer();
var config1 = container.GetConfiguration();
var config2 = config1.Configure <Bar>(new InjectedProperty <Foo>("Foo", new Foo()));
Assert.AreSame(config1, config2);
}
public void ResolveAllUnregisteredTypeReturnsEmptyCollection()
{
var ioc = new MicroIocContainer();
var instances = ioc.ResolveAll(typeof(Foo));
Assert.IsNotNull(instances);
Assert.AreEqual(0, instances.Count());
}
public void ContainerRetrievesInstancesByKeyWithSingleParameterTypeRegistration()
{
var iocContainer = new MicroIocContainer()
.Register <Foo2>("Foo2", true);
var instance = iocContainer.Resolve(null, "Foo2");
Assert.IsInstanceOfType(instance, typeof(Foo2));
Assert.IsNotNull(instance);
}
public void ContainerRetrievesInstancesByKey()
{
var iocContainer = new MicroIocContainer()
.Register <IFoo, Foo>("Foo", true);
var instance = iocContainer.Resolve(null, "Foo");
Assert.IsInstanceOfType(instance, typeof(Foo));
Assert.IsNotNull(instance);
}
public void ContainerWillChainDependencyInjection()
{
var iocContainer = new MicroIocContainer()
.Register <IFoo, Foo>();
var instance = iocContainer.Resolve <Bar>();
Assert.IsNotNull(instance);
Assert.IsNotNull(instance.Foo);
}
public void ResolveCreatesInstancePerRequest()
{
var iocContainer = new MicroIocContainer()
.Register <IFoo, Foo>();
var instance1 = iocContainer.Resolve <IFoo>();
var instance2 = iocContainer.Resolve <IFoo>();
Assert.AreNotSame(instance1, instance2);
}
public void TryResolveRegisteredInterfaceReturnsInstance()
{
var iocContainer = new MicroIocContainer()
.Register <IFoo, Foo>();
var instance = iocContainer.TryResolve(typeof(IFoo));
Assert.IsNotNull(instance, "Instance should not be null");
Assert.IsInstanceOfType(instance, typeof(IFoo));
}
public void ResolveCreatesSingletonIfSpecified()
{
var iocContainer = new MicroIocContainer()
.Register <IFoo, Foo>(isSingleton: true);
var instance1 = iocContainer.Resolve <IFoo>();
var instance2 = iocContainer.Resolve <IFoo>();
Assert.AreSame(instance1, instance2);
}
public void RegisteringSubsequentImplentationTypesOverwritesPrevious()
{
var iocContainer = new MicroIocContainer()
.Register <IFoo, Foo>();
Assert.IsInstanceOfType(iocContainer.Resolve <IFoo>(), typeof(Foo));
iocContainer.Register <IFoo, Foo2>();
Assert.IsInstanceOfType(iocContainer.Resolve <IFoo>(), typeof(Foo2));
}
public void ContainerCanResolveAConcreteTypeWithoutDefaultConstructor()
{
var iocContainer = new MicroIocContainer()
.Register <IFoo, Foo>();
var instance = iocContainer.Resolve <IFoo>();
Assert.IsNotNull(instance);
Assert.IsInstanceOfType(instance, typeof(Foo));
}
public void ContainerWillResolveSpecificInstancesInChainedResolution()
{
var foo1 = new Foo();
var iocContainer = new MicroIocContainer()
.RegisterInstance <IFoo>(foo1);
var instance = iocContainer.Resolve <Bar>();
Assert.IsNotNull(instance);
Assert.AreSame(foo1, instance.Foo);
}
public void ConfigurationHoldsReferenceToContainer()
{
var container = new MicroIocContainer();
var configuration = container.GetConfiguration();
var configType = configuration.GetType();
var fieldInfo = configType.GetField("_container", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.AreSame(container, fieldInfo.GetValue(configuration));
}
public void ResolveAllReturnsSingleRegisteredTypeInACollection()
{
var ioc = new MicroIocContainer()
.Register <IFoo, Foo>();
var instances = ioc.ResolveAll(typeof(IFoo));
Assert.IsNotNull(instances);
Assert.AreEqual(1, instances.Count());
Assert.IsInstanceOfType(instances.Single(), typeof(IFoo), "Registered instance should be an IFoo");
}
public void InjectionWorksOnProperties()
{
const string expectedName = "Fabrikam inc.";
var iocContainer = new MicroIocContainer()
.RegisterInstance(expectedName, "MicroIoc.Tests.TestClassWithProperty.CustomerName");
var instance = iocContainer.Resolve <TestClassWithProperty>();
Assert.AreEqual(expectedName, instance.CustomerName);
}
public void ResolveAllReturnsAllRegisteredTypesInACollection()
{
var ioc = new MicroIocContainer()
.Register <IFoo, Foo>("One")
.RegisterInstance <IFoo>(new Foo(), "Two")
.Register <IFoo, Foo>("Three", true);
var instances = ioc.ResolveAll(typeof(IFoo));
Assert.IsNotNull(instances);
Assert.AreEqual(3, instances.Count());
}
public void ContainerInstantiatesConstructorWithMostParameters()
{
var iocContainer = new MicroIocContainer()
.Register <IFirst, First>()
.Register <ISecond, Second>()
.Register <IThird, Third>();
var instance = iocContainer.Resolve <OverloadedTestClass>();
Assert.IsNotNull(instance.First);
Assert.IsNotNull(instance.Second);
Assert.IsNotNull(instance.Third);
}
public void BuildUpAppliesDependencyProperty()
{
var container = new MicroIocContainer();
container.GetConfiguration()
.Property <TestClassWithProperty, string>(x => x.CustomerName, "TestCustomerName");
var obj = new TestClassWithProperty();
container.BuildUp(obj);
Assert.AreEqual("TestCustomerName", obj.CustomerName);
}
public void PropertyInjectionThrowsExceptionForUnregisteredDependency()
{
const string expectedName = "Fabrikam inc.";
var iocContainer = new MicroIocContainer()
.RegisterInstance(expectedName)
.Register <IFirst, First>();
// Do not register this one...
// iocContainer.Register<ISecond, Second>();
iocContainer.Resolve <TestClassWithProperties>();
}
public void BuildUpAppliesDependencyProperty()
{
var container = new MicroIocContainer();
container.GetConfiguration()
.Property<TestClassWithProperty, string>(x => x.CustomerName, "TestCustomerName");
var obj = new TestClassWithProperty();
container.BuildUp(obj);
Assert.AreEqual("TestCustomerName", obj.CustomerName);
}
public void ConfiguredPropertyInjectionGetsResolved()
{
const string customerName = "Bloggs & Co";
var container = new MicroIocContainer()
.Register <IFirst, First>()
.Register <ISecond, Second>();
container.GetConfiguration()
.Property <TestClassWithProperties, string>(c => c.CustomerName, customerName);
var instance = container.Resolve <TestClassWithProperties>();
Assert.AreEqual(customerName, instance.CustomerName);
}
public void BuildUpDoesNotApplyStandardProperty()
{
var container = new MicroIocContainer();
container.GetConfiguration()
.Property <TestClassWithProperty, string>(x => x.CustomerName, "TestCustomerName")
.Property <TestClassWithProperty, string>(x => x.NotInjected, "NotInjected");
var obj = new TestClassWithProperty();
container.BuildUp(obj);
Assert.IsNull(obj.NotInjected, string.Format("Should have been null, but was {0}", obj.NotInjected));
}
public void ResolveByKeyGetsCorrectInstance()
{
var foo1 = new Foo();
var foo2 = new Foo();
var iocContainer = new MicroIocContainer()
.RegisterInstance <IFoo>(foo1)
.RegisterInstance <IFoo>(foo2, "theKey");
var instance = iocContainer.Resolve <IFoo>("theKey");
Assert.AreNotSame(instance, foo1);
Assert.AreSame(instance, foo2);
}
public void ConfiguredConstructorParameterInjectionGetsResolved()
{
const string connectionString =
"Data Source=myServerAddress;Initial Catalog=myDataBase;User Id=myUsername;Password=myPassword;";
var container = new MicroIocContainer();
container.GetConfiguration()
.ConstructorParam <SampleRepository, string>("connectionString", connectionString);
var instance = container.Resolve <SampleRepository>();
Assert.AreEqual(connectionString, instance.ConnectionString);
}
public void BuildUpDoesNotApplyStandardProperty()
{
var container = new MicroIocContainer();
container.GetConfiguration()
.Property<TestClassWithProperty, string>(x => x.CustomerName, "TestCustomerName")
.Property<TestClassWithProperty, string>(x => x.NotInjected, "NotInjected");
var obj = new TestClassWithProperty();
container.BuildUp(obj);
Assert.IsNull(obj.NotInjected, string.Format("Should have been null, but was {0}", obj.NotInjected));
}
public void BuildUpResolvesAllInjectedProperties()
{
var container = new MicroIocContainer()
.Register<IFirst, First>()
.Register<ISecond, Second>();
container.GetConfiguration()
.Property<TestClassWithProperties, string>(x => x.CustomerName, "TestCustomerName");
var obj = new TestClassWithProperties();
container.BuildUp(obj);
Assert.AreEqual("TestCustomerName", obj.CustomerName);
Assert.IsNotNull(obj.FirstProperty, "FirstProperty shouldn't be null");
Assert.IsInstanceOfType(obj.FirstProperty, typeof(First), "FirstProperty should a 'First' object");
Assert.IsNotNull(obj.SecondProperty, "SecondProperty shouldn't be null");
Assert.IsInstanceOfType(obj.SecondProperty, typeof(Second), "SecondProperty should a 'Second' object");
}
public void RegistrationOfInvalidTypeThrowsException()
{
bool wasThrown = false;
try
{
IMicroIocContainer iocContainer = new MicroIocContainer()
.Register<IFoo>(typeof(Bar), "key", false);
}
catch (RegistrationException)
{
wasThrown = true;
}
Assert.IsTrue(wasThrown, "The registration should have thrown an exception");
}
public void ContainerWillChainDependencyInjection()
{
var iocContainer = new MicroIocContainer()
.Register<IFoo, Foo>();
var instance = iocContainer.Resolve<Bar>();
Assert.IsNotNull(instance);
Assert.IsNotNull(instance.Foo);
}
public void TryResolveUnregisteredInterfaceWithKeyReturnsNull()
{
IMicroIocContainer iocContainer = new MicroIocContainer();
var instance = iocContainer.TryResolve(typeof(IFoo), "SomeKey");
Assert.IsNull(instance, "Instance should be null");
}
public void ResoveCreatesItemOfRequiredType()
{
var iocContainer = new MicroIocContainer()
.Register<IFoo, Foo>();
var instance = iocContainer.Resolve<IFoo>();
Assert.IsInstanceOfType(instance, typeof(Foo));
}
public void ResolveCreatesInstancePerRequest()
{
var iocContainer = new MicroIocContainer()
.Register<IFoo, Foo>();
var instance1 = iocContainer.Resolve<IFoo>();
var instance2 = iocContainer.Resolve<IFoo>();
Assert.AreNotSame(instance1, instance2);
}
public void ResolveAllUnregisteredTypeReturnsEmptyCollection()
{
var ioc = new MicroIocContainer();
var instances = ioc.ResolveAll(typeof (Foo));
Assert.IsNotNull(instances);
Assert.AreEqual(0, instances.Count());
}
public void RegisterAllViewModelsCreatesRegistrationByNameForVmsInAssembly()
{
var iocContainer = new MicroIocContainer()
.RegisterAllViewModels();
var threw = false;
try
{
var foo = iocContainer.Resolve(null, "FooViewModel");
Assert.IsInstanceOfType(foo, typeof(FooViewModel));
var bar = iocContainer.Resolve(null, "BarViewModel");
Assert.IsInstanceOfType(bar, typeof(BarViewModel));
}
catch (Exception)
{
threw = true;
}
finally
{
Assert.IsFalse(threw);
}
}
public void PropertyInjectionThrowsExceptionForUnregisteredDependency()
{
const string expectedName = "Fabrikam inc.";
var iocContainer = new MicroIocContainer()
.RegisterInstance(expectedName)
.Register<IFirst, First>();
// Do not register this one...
// iocContainer.Register<ISecond, Second>();
iocContainer.Resolve<TestClassWithProperties>();
}
public void InjectionWorksOnProperties()
{
const string expectedName = "Fabrikam inc.";
var iocContainer = new MicroIocContainer()
.RegisterInstance(expectedName, "MicroIoc.Tests.TestClassWithProperty.CustomerName");
var instance = iocContainer.Resolve<TestClassWithProperty>();
Assert.AreEqual(expectedName, instance.CustomerName);
}
public void GenericTryResolveUnregisteredInterfaceReturnsNull()
{
IMicroIocContainer iocContainer = new MicroIocContainer();
var instance = iocContainer.TryResolve<IFoo>();
Assert.IsNull(instance, "Instance should be null");
}
public void ContainerRetrievesInstancesByKey()
{
var iocContainer = new MicroIocContainer()
.Register<IFoo, Foo>("Foo", true);
var instance = iocContainer.Resolve(null, "Foo");
Assert.IsInstanceOfType(instance, typeof(Foo));
Assert.IsNotNull(instance);
}
public void GenericTryResolveRegisteredInterfaceWithInvalidKeyReturnsNull()
{
var iocContainer = new MicroIocContainer()
.Register<IFoo, Foo>();
var instance = iocContainer.TryResolve<IFoo>("SomeKey");
Assert.IsNull(instance, "Instance should be null");
}
public void ContainerWillResolveSpecificInstancesInChainedResolution()
{
var foo1 = new Foo();
var iocContainer = new MicroIocContainer()
.RegisterInstance<IFoo>(foo1);
var instance = iocContainer.Resolve<Bar>();
Assert.IsNotNull(instance);
Assert.AreSame(foo1, instance.Foo);
}
public void ResolveAllReturnsAllRegisteredTypesInACollection()
{
var ioc = new MicroIocContainer()
.Register<IFoo, Foo>("One")
.RegisterInstance<IFoo>(new Foo(), "Two")
.Register<IFoo, Foo>("Three", true);
var instances = ioc.ResolveAll(typeof(IFoo));
Assert.IsNotNull(instances);
Assert.AreEqual(3, instances.Count());
}
public void ResolveAllReturnsSingleRegisteredTypeInACollection()
{
var ioc = new MicroIocContainer()
.Register<IFoo, Foo>();
var instances = ioc.ResolveAll(typeof(IFoo));
Assert.IsNotNull(instances);
Assert.AreEqual(1, instances.Count());
Assert.IsInstanceOfType(instances.Single(), typeof(IFoo), "Registered instance should be an IFoo");
}
public void RegisterAllViewModelsDoesNotRegisterUnknownVms()
{
var iocContainer = new MicroIocContainer()
.RegisterAllViewModels();
var threw = false;
try
{
// There is no such object - this should throw a ResolutionException
var foo = iocContainer.Resolve(null, "BazViewModel");
}
catch (ResolutionException)
{
threw = true;
}
finally
{
Assert.IsTrue(threw);
}
}
public void ResolveByKeyGetsCorrectInstance()
{
var foo1 = new Foo();
var foo2 = new Foo();
var iocContainer = new MicroIocContainer()
.RegisterInstance<IFoo>(foo1)
.RegisterInstance<IFoo>(foo2, "theKey");
var instance = iocContainer.Resolve<IFoo>("theKey");
Assert.AreNotSame(instance, foo1);
Assert.AreSame(instance, foo2);
}
public void RegisteringSubsequentImplentationTypesOverwritesPrevious()
{
var iocContainer = new MicroIocContainer()
.Register<IFoo, Foo>();
Assert.IsInstanceOfType(iocContainer.Resolve<IFoo>(), typeof(Foo));
iocContainer.Register<IFoo, Foo2>();
Assert.IsInstanceOfType(iocContainer.Resolve<IFoo>(), typeof(Foo2));
}
public void ResolveCreatesSingletonIfSpecified()
{
var iocContainer = new MicroIocContainer()
.Register<IFoo, Foo>(isSingleton: true);
var instance1 = iocContainer.Resolve<IFoo>();
var instance2 = iocContainer.Resolve<IFoo>();
Assert.AreSame(instance1, instance2);
}
public void RegisteringSubsequentInstancesOfTypeWithSameKeyOverwritesPrevious()
{
const string key = "fooKey"; // Nell
var foo1 = new Foo();
var foo2 = new Foo();
var iocContainer = new MicroIocContainer()
.RegisterInstance<IFoo>(foo1, key);
Assert.AreSame(foo1, iocContainer.Resolve<IFoo>(key));
iocContainer.RegisterInstance<IFoo>(foo2, key);
Assert.AreSame(foo2, iocContainer.Resolve<IFoo>(key));
}
public void TryResolveRegisteredInterfaceReturnsInstance()
{
var iocContainer = new MicroIocContainer()
.Register<IFoo, Foo>();
var instance = iocContainer.TryResolve(typeof (IFoo));
Assert.IsNotNull(instance, "Instance should not be null");
Assert.IsInstanceOfType(instance, typeof(IFoo));
}
public void RegisterInstanceIsFluent()
{
IMicroIocContainer iocContainer = new MicroIocContainer();
var newContainer = iocContainer.RegisterInstance<IFoo>(new Foo());
Assert.AreSame(iocContainer, newContainer);
}
public void RegisterIsFluent()
{
IMicroIocContainer iocContainer = new MicroIocContainer();
var newContainer = iocContainer.Register<IFoo, Foo>();
Assert.AreSame(iocContainer, newContainer);
}
public void ContainerRetrievesInstancesByKeyWithSingleParameterTypeRegistration()
{
var iocContainer = new MicroIocContainer()
.Register<Foo2>("Foo2", true);
var instance = iocContainer.Resolve(null, "Foo2");
Assert.IsInstanceOfType(instance, typeof (Foo2));
Assert.IsNotNull(instance);
}
public void CanRegisterWithoutExceptions()
{
var threw = false;
try
{
var iocContainer = new MicroIocContainer();
iocContainer.Register<IFoo, Foo>();
}
catch (Exception)
{
threw = true;
}
finally
{
Assert.IsFalse(threw, "Failed to register without an exception");
}
}
public void ContainerInstantiatesConstructorWithMostParameters()
{
var iocContainer = new MicroIocContainer()
.Register<IFirst, First>()
.Register<ISecond, Second>()
.Register<IThird, Third>();
var instance = iocContainer.Resolve<OverloadedTestClass>();
Assert.IsNotNull(instance.First);
Assert.IsNotNull(instance.Second);
Assert.IsNotNull(instance.Third);
}
