Esempio n. 1
0
        public void ShouldResolvePropertiesByServiceLocator()
        {
            var locator = new ServiceLocator();

            locator
            .RegisterType <ITestClass, TestClassWIntListProperty>()
            .InjectProperty(classWProp => classWProp.Prop);

            var list = new List <int>();

            locator.RegisterInstance <IList <int>, List <int> >(list);

            var mapper = new TypeMapper <ClassW2Properties, ClassW4Properties>(locator);

            mapper.RegistrationInfo.IgnoreProperty(cl => cl.Prop);
            mapper.LocatorMappingInfo.InjectProperty(properties => properties.Prop4);

            var source = new ClassW2Properties {
                Prop2 = 2
            };
            var dest = mapper.Map(source);

            Assert.IsNotNull(dest);
            Assert.AreEqual(2, dest.Prop2);


            Assert.IsNotNull(dest.Prop4);
            var instance = dest.Prop4 as TestClassWIntListProperty;

            Assert.IsTrue(ReferenceEquals(instance.Prop, list));
        }
Esempio n. 2
0
        public void ShouldMapSourceTypeToDestConstructor()
        {
            var mapper = new TypeMapper <ClassW2Properties, ClassWithSourceCtor>();
            var source = new ClassW2Properties();
            var dest   = mapper.Map(source);

            Assert.IsNotNull(dest);
            Assert.AreEqual(dest.Source, source);
        }
Esempio n. 3
0
        public void ShouldResolvePropertyByInitalizer()
        {
            var mapper = new TypeMapper <ClassW2Properties, ClassWSourcePropertyInitalizer>();
            var source = new ClassW2Properties {
                Prop = 1, Prop2 = 2
            };
            var dest = mapper.Map(source);

            Assert.IsNotNull(dest);
            Assert.AreEqual(1, dest.Prop);
        }
Esempio n. 4
0
        public void ShouldInjectPropertyValue()
        {
            var mapper = new TypeMapper <ClassW2Properties, ClassW4Properties>();

            mapper.RegistrationInfo.InjectPropertyValue(cl => cl.Prop3, 3);
            var source = new ClassW2Properties();
            var dest   = mapper.Map(source);

            Assert.IsNotNull(dest);
            Assert.AreEqual(3, dest.Prop3);
        }
Esempio n. 5
0
        public void ShouldResolveCorrectPropertyWithSourcePropertyAttribute()
        {
            var mapper = new TypeMapper <ClassW2Properties, ClassWSourcePropertyMapAttribute>();
            var source = new ClassW2Properties {
                Prop = 1, Prop2 = 2
            };
            var dest = mapper.Map(source);

            Assert.IsNotNull(dest);
            Assert.AreEqual(2, dest.Prop);
            Assert.AreEqual(2, dest.Prop2);
        }
Esempio n. 6
0
        public void ShouldNotResolveNotRegisteredType()
        {
            var registry = new TypeMapperRegistry();
            var source   = new ClassW2Properties {
                Prop = 1, Prop2 = 2
            };

            var propertiesMapper = registry.Register <ClassW2Properties, ClassW4Properties>();

            propertiesMapper.InjectPropertyValue(properties => properties.Prop3, 3);

            registry.Resolve(source, typeof(ClassWithSourceCtor));
        }
Esempio n. 7
0
        public void ShouldIgnoreProperty()
        {
            var mapper = new TypeMapper <ClassW2Properties, ClassW4Properties>();

            mapper.RegistrationInfo.IgnoreProperty(cl => cl.Prop);
            var source = new ClassW2Properties {
                Prop = 1, Prop2 = 2
            };
            var dest = mapper.Map(source);

            Assert.IsNotNull(dest);
            Assert.AreEqual(0, dest.Prop);
            Assert.AreEqual(2, dest.Prop2);
        }
Esempio n. 8
0
        public void ShouldResolvePropertySetByBaseResolver()
        {
            var destType    = typeof(ClassW4Properties);
            var testBuilder = new TestTypeBuilder <ClassW2Properties, ClassW4Properties>();

            testBuilder.PropertyToResolve = destType.GetProperty("Prop3");
            testBuilder.ProertyValue      = 3;

            var mapper = new TestTypeMapper <ClassW2Properties, ClassW4Properties>(() => testBuilder);
            var source = new ClassW2Properties();
            var dest   = mapper.Map(source);

            Assert.IsNotNull(dest);
            Assert.AreEqual(3, dest.Prop3);
        }
Esempio n. 9
0
        public void ShouldMapInjectedProperties()
        {
            var registry = new TypeMapperRegistry();
            var source   = new ClassW2Properties {
                Prop = 1, Prop2 = 2
            };

            var propertiesMapper = registry.Register <ClassW2Properties, ClassW4Properties>();

            propertiesMapper.InjectPropertyValue(properties => properties.Prop3, 3);

            ClassW4Properties dest = registry.Resolve(source, typeof(ClassW4Properties)) as ClassW4Properties;

            Assert.IsNotNull(dest);
            Assert.IsTrue(dest.Prop == 1);
            Assert.IsTrue(dest.Prop3 == 3);
        }
Esempio n. 10
0
        public void ShouldMapIdenticallyNamedTypeProperties()
        {
            var registry = new TypeMapperRegistry();
            var source   = new ClassW2Properties {
                Prop = 1, Prop2 = 2
            };

            var mapper = new TypeMapper <ClassW2Properties, ClassW4Properties>();

            registry.Register <ClassW2Properties, ClassW4Properties>(mapper);

            var dest = registry.Resolve <ClassW4Properties>(source);

            Assert.IsNotNull(dest);
            Assert.IsTrue(dest.Prop == 1);
            Assert.IsTrue(dest.Prop2 == 2);
        }
Esempio n. 11
0
        public void ShouldUserPriorBuilder()
        {
            var destType    = typeof(ClassW4Properties);
            var testBuilder = new TestTypeBuilder <ClassW2Properties, ClassW4Properties>();

            testBuilder.PropertyToResolve = destType.GetProperty("Prop2");
            testBuilder.ProertyValue      = 3;

            var mapper = new TestTypeMapper <ClassW2Properties, ClassW4Properties>(() => testBuilder);
            var source = new ClassW2Properties {
                Prop2 = 2
            };
            var dest = mapper.Map(source);

            Assert.IsNotNull(dest);
            Assert.AreEqual(2, dest.Prop2);
        }
Esempio n. 12
0
        public void ShouldResolveDestTypeDescendants()
        {
            var registry = new TypeMapperRegistry();
            var source   = new ClassW2Properties {
                Prop = 1, Prop2 = 2
            };

            var mapper = new TypeMapper <ClassW2Properties, ClassW4PropertiesDescendant1>();

            registry.Register <ClassW2Properties, ClassW4PropertiesDescendant1>(mapper);
            registry.Register <ClassW2Properties, ClassW4PropertiesDescendant2>();
            registry.Register <ClassW2Properties, ClassW4Properties>();

            var dest = registry.ResolveDescendants <ClassW4Properties>(source);

            Assert.IsNotNull(dest);
            Assert.IsTrue(dest.Count() == 3);
            Assert.IsTrue(dest.All(properties => properties.Prop2 == 2));
            Assert.IsTrue(dest.All(properties => properties.Prop == 1));
        }
Esempio n. 13
0
 public ClassWithSourceCtor(ClassW2Properties source)
 {
     Source = source;
 }