public void ResolverWithElementsReturnsResolvedElementsForBaseClass()
{
IUnityContainer container = new UnityContainer();
ILogger o1 = new MockLogger();
ILogger o2 = new SpecialLogger();
container
.RegisterInstance <ILogger>("o1", o1)
.RegisterInstance <ILogger>("o2", o2);
ResolvedArrayWithElementsResolverPolicy resolver
= new ResolvedArrayWithElementsResolverPolicy(
typeof(ILogger),
new NamedTypeDependencyResolverPolicy(typeof(ILogger), "o1"),
new NamedTypeDependencyResolverPolicy(typeof(ILogger), "o2"));
container.AddExtension(new InjectedObjectConfigurationExtension(resolver));
ILogger[] results = (ILogger[])container.Resolve <InjectedObject>().injectedValue;
Assert.IsNotNull(results);
Assert.AreEqual(2, results.Length);
Assert.AreSame(o1, results[0]);
Assert.AreSame(o2, results[1]);
}
public void ResolverWithElementsReturnsResolvedElementsForBaseClass()
{
// Arrange
ILogger o1 = new MockLogger();
ILogger o2 = new SpecialLogger();
Container.RegisterInstance("o1", o1)
.RegisterInstance("o2", o2)
.RegisterType <InjectedObject>(Invoke.Constructor(typeof(ILogger[])))
.RegisterType <InjectedObject>(Legacy, new InjectionConstructor(typeof(ILogger[])));
// Act
var result = (ILogger[])Container.Resolve <InjectedObject>().InjectedValue;
var legacy = (object[])Container.Resolve <InjectedObject>().InjectedValue;
// Validate
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Length);
Assert.AreSame(o1, result[0]);
Assert.AreSame(o2, result[1]);
Assert.IsNotNull(legacy);
Assert.AreEqual(2, legacy.Length);
Assert.AreSame(o1, legacy[0]);
Assert.AreSame(o2, legacy[1]);
}
public void CreatingResolvedArrayParameterWithValuesOfNonCompatibleType()
{
ILogger logger2 = new SpecialLogger();
new ResolvedArrayParameter <ILogger>(
new ResolvedParameter <ILogger>("log1"),
typeof(int),
logger2);
}
public void CreatingResolvedArrayParameterWithValuesOfNonCompatibleType()
{
ILogger logger2 = new SpecialLogger();
AssertExtensions.AssertException <InvalidOperationException>(() =>
{
new ResolvedArrayParameter <ILogger>(
new ResolvedParameter <ILogger>("log1"),
typeof(int),
logger2);
});
}
public void ResolveAllReturnsRegisteredObjectsForBaseClass()
{
IUnityContainer container = new UnityContainer();
ILogger o1 = new MockLogger();
ILogger o2 = new SpecialLogger();
container
.RegisterInstance<ILogger>("o1", o1)
.RegisterInstance<ILogger>("o2", o2);
List<ILogger> results = new List<ILogger>(container.ResolveAll<ILogger>());
CollectionAssert.AreEqual(new ILogger[] {o1, o2}, results);
}
public void ResolveAllReturnsRegisteredObjectsForBaseClass()
{
IUnityContainer container = new UnityContainer();
ILogger o1 = new MockLogger();
ILogger o2 = new SpecialLogger();
container
.RegisterInstance <ILogger>("o1", o1)
.RegisterInstance <ILogger>("o2", o2);
List <ILogger> results = new List <ILogger>(container.ResolveAll <ILogger>());
CollectionAssert.AreEqual(new ILogger[] { o1, o2 }, results);
}
public void CanResolveArrayForConstructorParameter()
{
ILogger o1 = new MockLogger();
ILogger o2 = new SpecialLogger();
Container.RegisterInstance <ILogger>("o1", o1)
.RegisterInstance <ILogger>("o2", o2);
var resolved = Container.Resolve <TypeWithArrayConstructorParameter>();
Assert.IsNotNull(resolved.Loggers);
Assert.AreEqual(2, resolved.Loggers.Length);
Assert.AreSame(o1, resolved.Loggers[0]);
Assert.AreSame(o2, resolved.Loggers[1]);
}
public void CreatingResolvedArrayParameterWithValuesOfNonCompatibleType()
{
ILogger logger2 = new SpecialLogger();
try
{
new ResolvedArrayParameter <ILogger>(
new ResolvedParameter <ILogger>("log1"),
typeof(int),
logger2);
Assert.Fail("Should have thrown");
}
catch (InvalidOperationException)
{
}
}
public void CanResolveArrayForProperty()
{
ILogger o1 = new MockLogger();
ILogger o2 = new SpecialLogger();
IUnityContainer container
= new UnityContainer()
.RegisterInstance <ILogger>("o1", o1)
.RegisterInstance <ILogger>("o2", o2);
TypeWithArrayProperty resolved = container.Resolve <TypeWithArrayProperty>();
Assert.IsNotNull(resolved.Loggers);
Assert.AreEqual(2, resolved.Loggers.Length);
Assert.AreSame(o1, resolved.Loggers[0]);
Assert.AreSame(o2, resolved.Loggers[1]);
}
public void CanConfigureContainerToCallConstructorWithArrayParameterWithNonGenericVersion()
{
ILogger o1 = new MockLogger();
ILogger o2 = new SpecialLogger();
IUnityContainer container = new UnityContainer()
.RegisterType <TypeWithArrayConstructorParameter>(new InjectionConstructor(typeof(ILogger[])))
.RegisterInstance <ILogger>("o1", o1)
.RegisterInstance <ILogger>("o2", o2);
TypeWithArrayConstructorParameter resolved = container.Resolve <TypeWithArrayConstructorParameter>();
Assert.NotNull(resolved.Loggers);
Assert.Equal(2, resolved.Loggers.Length);
Assert.Same(o1, resolved.Loggers[0]);
Assert.Same(o2, resolved.Loggers[1]);
}
public void CanResolveArrayForConstructorParameterOnClosedGenericType()
{
ILogger o1 = new MockLogger();
ILogger o2 = new SpecialLogger();
IUnityContainer container
= new UnityContainer()
.RegisterInstance <ILogger>("o1", o1)
.RegisterInstance <ILogger>("o2", o2);
GenericTypeWithArrayConstructorParameter <ILogger> resolved
= container.Resolve <GenericTypeWithArrayConstructorParameter <ILogger> >();
Assert.IsNotNull(resolved.values);
Assert.AreEqual(2, resolved.values.Length);
Assert.AreSame(o1, resolved.values[0]);
Assert.AreSame(o2, resolved.values[1]);
}
public void CanConfigureContainerToCallConstructorWithArrayParameter()
{
// Arrange
ILogger o1 = new MockLogger();
ILogger o2 = new SpecialLogger();
Container.RegisterType <TypeWithArrayConstructorParameter>(new InjectionConstructor(typeof(ILogger[])))
.RegisterInstance <ILogger>("o1", o1)
.RegisterInstance <ILogger>("o2", o2);
// Act
var resolved = Container.Resolve <TypeWithArrayConstructorParameter>();
Assert.IsNotNull(resolved.Loggers);
Assert.AreEqual(2, resolved.Loggers.Length);
Assert.AreSame(o1, resolved.Loggers[0]);
Assert.AreSame(o2, resolved.Loggers[1]);
}
public void CanConfigureContainerToInjectSpecificValuesIntoAnArray()
{
ILogger logger2 = new SpecialLogger();
IUnityContainer container = new UnityContainer()
.RegisterType <TypeWithArrayConstructorParameter>(
new InjectionConstructor(
new ResolvedArrayParameter <ILogger>(
new ResolvedParameter <ILogger>("log1"),
typeof(ILogger),
logger2)))
.RegisterType <ILogger, MockLogger>()
.RegisterType <ILogger, SpecialLogger>("log1");
TypeWithArrayConstructorParameter result = container.Resolve <TypeWithArrayConstructorParameter>();
Assert.Equal(3, result.Loggers.Length);
AssertExtensions.IsInstanceOfType(result.Loggers[0], typeof(SpecialLogger));
AssertExtensions.IsInstanceOfType(result.Loggers[1], typeof(MockLogger));
Assert.Same(logger2, result.Loggers[2]);
}
public void CanConfigureContainerToInjectSpecificValuesIntoAnArrayWithNonGenericVersion()
{
// Arrange
ILogger logger2 = new SpecialLogger();
Container.RegisterType <TypeWithArrayConstructorParameter>(
new InjectionConstructor(
new ResolvedArrayParameter(
typeof(ILogger),
new ResolvedParameter <ILogger>("log1"),
typeof(ILogger),
logger2)))
.RegisterType <ILogger, MockLogger>()
.RegisterType <ILogger, SpecialLogger>("log1");
// Act
var result = Container.Resolve <TypeWithArrayConstructorParameter>();
Assert.AreEqual(3, result.Loggers.Length);
Assert.IsInstanceOfType(result.Loggers[0], typeof(SpecialLogger));
Assert.IsInstanceOfType(result.Loggers[1], typeof(MockLogger));
Assert.AreSame(logger2, result.Loggers[2]);
}
public void ResolverWithElementsReturnsResolvedElementsForBaseClass()
{
IUnityContainer container = new UnityContainer();
ILogger o1 = new MockLogger();
ILogger o2 = new SpecialLogger();
container
.RegisterInstance<ILogger>("o1", o1)
.RegisterInstance<ILogger>("o2", o2);
ResolvedArrayWithElementsResolverPolicy resolver
= new ResolvedArrayWithElementsResolverPolicy(
typeof(ILogger),
new NamedTypeDependencyResolverPolicy(typeof(ILogger), "o1"),
new NamedTypeDependencyResolverPolicy(typeof(ILogger), "o2"));
container.AddExtension(new InjectedObjectConfigurationExtension(resolver));
ILogger[] results = (ILogger[])container.Resolve<InjectedObject>().injectedValue;
Assert.IsNotNull(results);
Assert.AreEqual(2, results.Length);
Assert.AreSame(o1, results[0]);
Assert.AreSame(o2, results[1]);
}
