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); }