public void ResolverWithElementsReturnsLiteralElements()
{
// Arrange
object o1 = new object();
object o2 = new object();
object o3 = new object();
Container.RegisterInstance("o1", o1)
.RegisterInstance("o2", o2)
.RegisterType <InjectedObject>(
Invoke.Constructor(Inject.Parameter(new object[] { o1, o3 })))
.RegisterType <InjectedObject>(Legacy,
new InjectionConstructor(
new ResolvedArrayParameter(typeof(object),
new InjectionParameter(typeof(object), o1),
new InjectionParameter(typeof(object), o3))));
// Act
var result = (object[])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(o3, result[1]);
Assert.IsNotNull(legacy);
Assert.AreEqual(2, legacy.Length);
Assert.AreSame(o1, legacy[0]);
Assert.AreSame(o3, legacy[1]);
}
public void LazyFunc()
{
// Arrange
Container.RegisterType(typeof(IList <>), typeof(List <>), Invoke.Constructor());
Container.RegisterType(typeof(IFoo <>), typeof(Foo <>));
Container.RegisterType <IService, Service>("1");
Container.RegisterType <IService, Service>("2");
Container.RegisterType <IService, Service>("3");
Container.RegisterType <IService, Service>();
Service.Instances = 0;
// Act
var array = Container.Resolve <Lazy <Func <IService> >[]>();
// Verify
Assert.AreEqual(0, Service.Instances);
Assert.IsNotNull(array);
Assert.AreEqual(3, array.Length);
Assert.IsNotNull(array[0].Value);
Assert.IsNotNull(array[1].Value);
Assert.IsNotNull(array[2].Value);
Assert.AreEqual(0, Service.Instances);
Assert.IsNotNull(array[0].Value());
Assert.IsNotNull(array[1].Value());
Assert.IsNotNull(array[2].Value());
Assert.AreEqual(3, Service.Instances);
}
public void ResolverWithElementsReturnsEmptyArrayIfThereAreNoElements()
{
// Arrange
object o1 = new object();
object o2 = new object();
Container.RegisterInstance("o1", o1)
.RegisterInstance("o2", o2)
.RegisterType <InjectedObject>(Invoke.Constructor(Inject.Array <object>()))
.RegisterType <InjectedObject>(Legacy,
new InjectionConstructor(new ResolvedArrayParameter(typeof(object))));
// Act
var result = (object[])Container.Resolve <InjectedObject>().InjectedValue;
var legacy = (object[])Container.Resolve <InjectedObject>(Legacy).InjectedValue;
// Validate
Assert.IsNotNull(result);
Assert.AreEqual(0, result.Length);
Assert.IsNotNull(legacy);
Assert.AreEqual(0, legacy.Length);
}
public void SelectByValueTypes()
{
Container.RegisterType <TypeWithMultipleCtors>(Invoke.Constructor(Inject.Parameter(typeof(string)),
Inject.Parameter(typeof(string)),
Inject.Parameter(typeof(int))));
Assert.AreEqual(TypeWithMultipleCtors.Three, Container.Resolve <TypeWithMultipleCtors>().Signature);
}
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 NoArgsDefaultParameterValue()
{
// Arguments of the same type should have their relative ordering preserved when the
// method has multiple arguments of that type
var result = Invoke.Constructor(typeof(TestObject2));
(result.Value as TestObject2).Value.Should().Be("A,0");
}
public void OrderedArguments()
{
// Arguments of the same type should have their relative ordering preserved when the
// method has multiple arguments of that type
var result = Invoke.Constructor(typeof(TestObject), 1, 2);
(result.Value as TestObject).Value.Should().Be("B,1,2");
}
public virtual void NoDefaultConstructor()
{
// Arrange
Container.RegisterType <ClassWithTreeConstructors>(Invoke.Constructor());
// Act
var instance = Container.Resolve <ClassWithTreeConstructors>();
}
public void NoReuse()
{
// Arrange
var ctor = Invoke.Constructor();
// Act
Container.RegisterType <TypeWithAmbiguousCtors>("1", ctor)
.RegisterType <TypeWithAmbiguousCtors>("2", ctor);
}
public virtual void NoBogusConstructor()
{
// Arrange
Container.RegisterType <ClassWithTreeConstructors>(
Invoke.Constructor(typeof(int), typeof(string)));
// Act
var instance = Container.Resolve <ClassWithTreeConstructors>();
}
public virtual void NoBogusValuesConstructor()
{
// Arrange
Container.RegisterType <ClassWithTreeConstructors>(
Invoke.Constructor(1, "test"));
// Act
var instance = Container.Resolve <ClassWithTreeConstructors>();
}
public virtual void NoConstructor()
{
// Act
Container.RegisterType <TypeWithAmbiguousCtors>(
Invoke.Constructor(Resolve.Parameter()));
// Act
var instance = Container.Resolve <TypeWithAmbiguousCtors>();
}
private static void CreateRegistrations()
{
container.RegisterFactory <GithubHookParser>(cnt => new GithubHookParser(fileName => FileNameValidator.Validate(fileName)));
container.RegisterType <ISalesUnitOfWork, SalesDbUnitOfWork>();
container.RegisterType <ISalesDataManager, SaleDbDataManager>();
container.RegisterType <SalesHandlerBase, GithubSalesHandler>();
container.RegisterType <ISaleDataSource, GithubSaleDataSource>();
container.RegisterType <ISalesHandlerFactory, SalesHandlerFactory>(Invoke.Constructor(Container));
}
public void MultipleConstructor()
{
// Arrange
Container.RegisterType <TypeWithAmbiguousCtors>(
Invoke.Constructor(),
Invoke.Constructor());
// Act
Container.Resolve <TypeWithAmbiguousCtors>();
}
public void DefaultCtorValidation(Type type, string name)
{
// Setup
Container.RegisterType((Type)null, type, name, null, Invoke.Constructor());
// Act
var result = Container.Resolve(type, name);
Assert.IsNotNull(result);
}
public async Task TypeAsync()
{
// Arrange
((IUnityContainer)Container).RegisterType <IFoo, Foo>(Invoke.Constructor());
// Act
var instance = await Container.ResolveAsync(typeof(IFoo));
// Validate
Assert.IsInstanceOfType(instance, typeof(Foo));
}
public override void Setup()
{
base.Setup();
Container.RegisterType <ObjectWithProperty>(
Invoke.Constructor(),
Resolve.Property(nameof(ObjectWithProperty.MyProperty)))
.RegisterType <IService, Service1>()
.RegisterType <IService, Service2>(Name)
.RegisterInstance(Name);
}
public void CtorParameter()
{
// Arrange
Container.RegisterType <Service>(Invoke.Constructor(_data));
// Act
var value = Container.Resolve <Service>(Override.Dependency <string>(_override));
// Verify
Assert.AreSame(_data, value.Data);
}
public void ContainerCanResolveListOfT()
{
// Arrange
Container.RegisterType(typeof(List <>), Invoke.Constructor());
// Act
var result = Container.Resolve <List <EmptyClass> >();
// Validate
Assert.IsNotNull(result);
}
public void Default(Type typeFrom, Type typeTo, string name, Type typeToResolve)
{
// Setup
Container.RegisterType(typeFrom, typeTo, name, null, Invoke.Constructor());
// Act
var result = Container.Resolve(typeToResolve, name);
// Verify
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeToResolve);
}
/// <summary>
/// Registers the type mappings with the Unity container.
/// </summary>
/// <param name="container">The unity container to configure.</param>
/// <remarks>
/// There is no need to register concrete types such as controllers or
/// API controllers (unless you want to change the defaults), as Unity
/// allows resolving a concrete type even if it was not previously
/// registered.
/// </remarks>
public static void RegisterTypes(IUnityContainer container)
{
// NOTE: To load from web.config uncomment the line below.
// Make sure to add a Unity.Configuration to the using statements.
// container.LoadConfiguration();
// TODO: Register your type's mappings here.
container.RegisterType <IMazeRepository, MazeInMemoryRepository>(new ContainerControlledLifetimeManager());
container.RegisterType <IRoomTypeRepository, RoomTypeInMemoryRepository>(new ContainerControlledLifetimeManager());
container.RegisterType <IMazeService, MazeService>(new TransientLifetimeManager());
container.RegisterType <IMapper, Mapper>(Invoke.Constructor(new Mapping().Configuration));
}
public void InjectionCtor()
{
// Arrange
Container.RegisterInstance(_data)
.RegisterType <Foo>(Invoke.Constructor(_override));
// Act
var value = Container.Resolve <Foo>();
// Verify
Assert.AreSame(_override, value.Data);
}
public void ConstructorWithData()
{
// Setup
Container.RegisterType(typeof(TypeWithAmbiguousCtors), Invoke.Constructor("1", "2", "3"));
// Act
var result = Container.Resolve <TypeWithAmbiguousCtors>();
// Validate
Assert.IsNotNull(result);
Assert.AreEqual(TypeWithAmbiguousCtors.Four, result.Signature);
}
public void Constructor()
{
// Setup
Container.RegisterType(null, typeof(TypeWithAmbiguousCtors), null, null, Invoke.Constructor());
// Act
var result = Container.Resolve <TypeWithAmbiguousCtors>();
// Validate
Assert.IsNotNull(result);
Assert.AreEqual(TypeWithAmbiguousCtors.One, result.Signature);
}
public void Selection(string name, Type typeFrom, Type typeTo, Type typeToResolve, object[] parameters, Func <object, bool> validator)
{
// Setup
Container.RegisterType(typeFrom, typeTo, name, null, Invoke.Constructor(parameters));
// Act
var result = Container.Resolve(typeToResolve, name);
// Verify
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeToResolve);
Assert.IsTrue(validator?.Invoke(result) ?? true);
}
public void CanProvideConstructorParameterViaResolveCall()
{
// Setup
const int configuredValue = 15; // Just need a number, value has no significance.
const int expectedValue = 42; // Just need a number, value has no significance.
Container.RegisterType <SimpleTestObject>(Invoke.Constructor(configuredValue));
// Act
var result = Container.Resolve <SimpleTestObject>(Override.Parameter("x", expectedValue));
// Verify
Assert.AreEqual(expectedValue, result.X);
}
public void MultipleConstructor()
{
// Arrange
Container.RegisterType <TypeWithAmbiguousCtors>(
Invoke.Constructor(),
Invoke.Constructor());
// Act
var instance = Container.Resolve <TypeWithAmbiguousCtors>();
// Validate
Assert.IsNotNull(instance);
Assert.AreEqual(TypeWithAmbiguousCtors.One, instance.Signature);
}
public void InjectDefaultCtorOpenGeneric()
{
// Arrange
#region inject_default_ctor_open_generic_arrange
Container.RegisterType(typeof(Service <>), Invoke.Constructor());
#endregion
// Act
var instance = Container.Resolve <Service <object> >();
// Validate
Assert.AreEqual(1, instance.Ctor);
}
public void CanInjectNestedGenerics()
{
// Setup
Container.RegisterType(typeof(ICommand <>), typeof(LoggingCommand <>),
Invoke.Constructor(Resolve.Parameter(typeof(ICommand <>), "concrete")))
.RegisterType(typeof(ICommand <>), typeof(ConcreteCommand <>), "concrete");
// Act
var cmd = Container.Resolve <ICommand <Customer?> >();
var logCmd = (LoggingCommand <Customer?>)cmd;
// Verify
Assert.IsNotNull(logCmd.Inner);
Assert.IsInstanceOfType(logCmd.Inner, typeof(ConcreteCommand <Customer?>));
}
public void OverrideDoeNotLastAfterResolveCall()
{
// Setup
const int configuredValue = 15; // Just need a number, value has no significance.
const int overrideValue = 42; // Just need a number, value has no significance.
Container.RegisterType <SimpleTestObject>(Invoke.Constructor(configuredValue));
// Act
Container.Resolve <SimpleTestObject>(Override.Parameter("x", overrideValue)
.OnType <SimpleTestObject>());
var result = Container.Resolve <SimpleTestObject>();
// Verify
Assert.AreEqual(configuredValue, result.X);
}
