public void OverridesDoNotApplyOnDifferentNamedTypeRegistered()
        {
            // Load the container details from the config file.
            IUnityContainer container = ConfigurationFixtureBase.GetContainer(@"ConfigFiles\PropertyOverride.config",
                "PropertyOverrideContainer");

            // Resolve using the type mentioned in the config files.
            var defaultConfigResult = container.Resolve<TestTypeInConfig>("MyTestTypeToOverride");

            // The default values in the config files should be present.
            Assert.AreEqual<int>(101, defaultConfigResult.Value);
            Assert.AreEqual<int>(-111, defaultConfigResult.X);
            Assert.AreEqual<string>("DefaultFromConfigFile", defaultConfigResult.Y);

            // Create the PropertyOverrides object.
            PropertyOverrides overrides = new PropertyOverrides();
            overrides.Add("X", 9999);
            overrides.Add("Y", "Overridden");

            // Resolve using the wrong type(only construction injection info available, no property injection info) mentioned in the config files.
            // Override is ignored.
            var overriddenResult = container.Resolve<TestTypeInConfig>("DefaultConstructor", overrides);

            // The default values in the config files should be retained.
            Assert.AreEqual<int>(1001, overriddenResult.Value);
            Assert.AreEqual<int>(0, overriddenResult.X);
            Assert.AreEqual<string>(null, overriddenResult.Y);
        }
        public void OverridesDoNotApplyOnDifferentNamedTypeRegistered()
        {
            // Load the container details from the config file.
            IUnityContainer container = ConfigurationFixtureBase.GetContainer(@"ConfigFiles\PropertyOverride.config",
                                                                              "PropertyOverrideContainer");

            // Resolve using the type mentioned in the config files.
            var defaultConfigResult = container.Resolve <TestTypeInConfig>("MyTestTypeToOverride");

            // The default values in the config files should be present.
            Assert.AreEqual <int>(101, defaultConfigResult.Value);
            Assert.AreEqual <int>(-111, defaultConfigResult.X);
            Assert.AreEqual <string>("DefaultFromConfigFile", defaultConfigResult.Y);

            // Create the PropertyOverrides object.
            PropertyOverrides overrides = new PropertyOverrides();

            overrides.Add("X", 9999);
            overrides.Add("Y", "Overridden");

            // Resolve using the wrong type(only construction injection info available, no property injection info) mentioned in the config files.
            // Override is ignored.
            var overriddenResult = container.Resolve <TestTypeInConfig>("DefaultConstructor", overrides);

            // The default values in the config files should be retained.
            Assert.AreEqual <int>(1001, overriddenResult.Value);
            Assert.AreEqual <int>(0, overriddenResult.X);
            Assert.AreEqual <string>(null, overriddenResult.Y);
        }
        public void CanOverrideMultipleInjectionPropertiesWithOverrideCollection()
        {
            TypeToInjectForPropertyOverride1 defaultObject  = new TypeToInjectForPropertyOverride1(111);
            TypeToInjectForPropertyOverride2 overrideObject = new TypeToInjectForPropertyOverride2(222);
            int defaultValue            = 111;
            int overrideValue           = 222;
            PropertyOverrides overrides = new PropertyOverrides();

            overrides.Add("X", overrideValue);
            overrides.Add("InjectedObject", overrideObject);

            IUnityContainer container = new UnityContainer();

            container.RegisterType <SubjectType1ToInjectForPropertyOverride>(
                new InjectionProperty("InjectedObject", defaultObject), new InjectionProperty("X", defaultValue));
            var result1 =
                (SubjectType1ToInjectForPropertyOverride)
                container.Resolve(typeof(SubjectType1ToInjectForPropertyOverride), overrides);
            var result2 = container.Resolve <SubjectType1ToInjectForPropertyOverride>();

            Assert.IsInstanceOfType(result1.InjectedObject, typeof(TypeToInjectForPropertyOverride2));
            Assert.AreEqual <int>(result1.X, overrideValue);
            Assert.IsInstanceOfType(result2.InjectedObject, typeof(TypeToInjectForPropertyOverride1));
            Assert.AreEqual <int>(result2.X, defaultValue);
        }
        public void PropertyOverrideWithDefaultInConfig()
        {
            TestTypeInConfig overrideObject = new TestTypeInConfig(666);

            IUnityContainer container = ConfigurationFixtureBase.GetContainer(@"ConfigFiles\PropertyOverride.config",
                "PropertyOverrideContainer");

            var defaultResult = container.Resolve<TestTypeInConfig>("MyTestTypeToOverride");
            PropertyOverrides overrides = new PropertyOverrides();
            overrides.Add("X", 9999);
            overrides.Add("Y", "Overridden");
            var overriddenResult = container.Resolve<TestTypeInConfig>("MyTestTypeToOverride", overrides);

            Assert.AreEqual<int>(101, defaultResult.Value);
            Assert.AreEqual<int>(-111, defaultResult.X);
            Assert.AreEqual<string>("DefaultFromConfigFile", defaultResult.Y);
            Assert.AreEqual<int>(101, overriddenResult.Value);
            Assert.AreEqual<int>(9999, overriddenResult.X);
            Assert.AreEqual<string>("Overridden", overriddenResult.Y);
        }
        public void PropertyOverrideWithCode()
        {
            TestTypeInConfig overrideObject = new TestTypeInConfig();

            IUnityContainer container = new UnityContainer();

            container.RegisterType <TestTypeInConfig>(new InjectionProperty("X", -111),
                                                      new InjectionProperty("Y", "default"), new InjectionConstructor());
            var defaultResult           = container.Resolve <TestTypeInConfig>();
            PropertyOverrides overrides = new PropertyOverrides();

            overrides.Add("X", 9999);
            overrides.Add("Y", "Overridden");
            var overriddenResult = container.Resolve <TestTypeInConfig>(overrides);

            Assert.AreEqual <int>(-111, defaultResult.X);
            Assert.AreEqual <string>("default", defaultResult.Y);
            Assert.AreEqual <int>(9999, overriddenResult.X);
            Assert.AreEqual <string>("Overridden", overriddenResult.Y);
        }
        public void PropertyOverrideWithDefaultInConfig()
        {
            TestTypeInConfig overrideObject = new TestTypeInConfig(666);

            IUnityContainer container = ConfigurationFixtureBase.GetContainer(@"ConfigFiles\PropertyOverride.config",
                                                                              "PropertyOverrideContainer");

            var defaultResult           = container.Resolve <TestTypeInConfig>("MyTestTypeToOverride");
            PropertyOverrides overrides = new PropertyOverrides();

            overrides.Add("X", 9999);
            overrides.Add("Y", "Overridden");
            var overriddenResult = container.Resolve <TestTypeInConfig>("MyTestTypeToOverride", overrides);

            Assert.AreEqual <int>(101, defaultResult.Value);
            Assert.AreEqual <int>(-111, defaultResult.X);
            Assert.AreEqual <string>("DefaultFromConfigFile", defaultResult.Y);
            Assert.AreEqual <int>(101, overriddenResult.Value);
            Assert.AreEqual <int>(9999, overriddenResult.X);
            Assert.AreEqual <string>("Overridden", overriddenResult.Y);
        }
        public void CanOverrideMultipleInjectionPropertiesWithOverrideCollection()
        {
            TypeToInjectForPropertyOverride1 defaultObject = new TypeToInjectForPropertyOverride1(111);
            TypeToInjectForPropertyOverride2 overrideObject = new TypeToInjectForPropertyOverride2(222);
            int defaultValue = 111;
            int overrideValue = 222;
            PropertyOverrides overrides = new PropertyOverrides();
            overrides.Add("X", overrideValue);
            overrides.Add("InjectedObject", overrideObject);

            IUnityContainer container = new UnityContainer();

            container.RegisterType<SubjectType1ToInjectForPropertyOverride>(
                new InjectionProperty("InjectedObject", defaultObject), new InjectionProperty("X", defaultValue));
            var result1 =
                (SubjectType1ToInjectForPropertyOverride)
                    container.Resolve(typeof(SubjectType1ToInjectForPropertyOverride), overrides);
            var result2 = container.Resolve<SubjectType1ToInjectForPropertyOverride>();

            Assert.IsInstanceOfType(result1.InjectedObject, typeof(TypeToInjectForPropertyOverride2));
            Assert.AreEqual<int>(result1.X, overrideValue);
            Assert.IsInstanceOfType(result2.InjectedObject, typeof(TypeToInjectForPropertyOverride1));
            Assert.AreEqual<int>(result2.X, defaultValue);
        }
        public void PropertyOverrideWithCode()
        {
            TestTypeInConfig overrideObject = new TestTypeInConfig();

            IUnityContainer container = new UnityContainer();

            container.RegisterType<TestTypeInConfig>(new InjectionProperty("X", -111),
                new InjectionProperty("Y", "default"), new InjectionConstructor());
            var defaultResult = container.Resolve<TestTypeInConfig>();
            PropertyOverrides overrides = new PropertyOverrides();
            overrides.Add("X", 9999);
            overrides.Add("Y", "Overridden");
            var overriddenResult = container.Resolve<TestTypeInConfig>(overrides);

            Assert.AreEqual<int>(-111, defaultResult.X);
            Assert.AreEqual<string>("default", defaultResult.Y);
            Assert.AreEqual<int>(9999, overriddenResult.X);
            Assert.AreEqual<string>("Overridden", overriddenResult.Y);
        }