public void BuildAutoResolverMapperTest5() { TransformerObserver observer = new TransformerObserver(); Assert.IsTrue(observer.BuildAutoResolverMapper(typeof(CustomSimpleTypeDto), typeof(CustomSimpleType))); Assert.IsTrue(observer.RegisterMapper(new SimpleMapper <int?, int>(i => i.GetValueOrDefault()))); CustomSimpleTypeDto instance = new CustomSimpleTypeDto { Naming = "naming", Code = 10 }; var res = observer.TryToMap <CustomSimpleTypeDto, CustomSimpleType>(instance); Assert.IsNotNull(res); Assert.AreEqual(res.Naming, instance.Naming); Assert.AreEqual(res.Code, instance.Code); var res1 = observer.TryToMap(instance, typeof(CustomSimpleType)) as CustomSimpleType; Assert.IsNotNull(res1); Assert.AreEqual(res1.Naming, instance.Naming); Assert.AreEqual(res1.Code, instance.Code); }
public void MakeTransformerBuilderTest2() { TransformerObserver observer = new TransformerObserver(); var mapper = observer.MakeTransformerBuilder <IPersonHeader, PersonDetails>(BuilderType.DefaultMappers); mapper.BuildMapper(); Assert.IsNotNull(mapper); IPersonHeader ps = new Person { Name = "name", Surname = "surname", AnnoNascita = 1980, Parent = null }; var resDto = observer.TryToMap <IPersonHeader, PersonDetails>(ps); Assert.IsNotNull(resDto); var resDto1 = observer.TryToMap(ps, typeof(PersonDetails)); Assert.IsNotNull(resDto1); Assert.IsTrue(resDto1 is PersonDetails); var resDto2 = observer.TryToMap <IPersonHeader, PersonDetails>(ps, "mykey"); Assert.IsNull(resDto2); var resDto3 = observer.TryToMap(ps, typeof(PersonDetails), "mykey"); Assert.IsNull(resDto3); }
public void RetreiveMapperFromObserver() { TransformerObserver observer = new TransformerObserver(); var builder = observer.MakeTransformerBuilder <IPersonHeader, PersonDetails>(BuilderType.DefaultMappers); var mapper1 = builder.BuildMapper(); var mapper2 = builder.BuildMapper("keymapper"); builder.BuildMerger(); builder.BuildMerger("merger"); Assert.IsNotNull(builder); Assert.AreEqual(mapper1, mapper2); Assert.AreNotSame(mapper1, mapper2); //IPersonHeader ps = new Person { Name = "name", Surname = "surname", AnnoNascita = 1980, Parent = null }; Assert.NotNull(observer.RetrieveMapper <ISourceMapper <IPersonHeader, PersonDetails> >()); Assert.Null(observer.RetrieveMapper <ISourceMapper <IPersonHeader, PersonDetails> >("mykey")); Assert.NotNull(observer.RetrieveMapper <ISourceMapper <IPersonHeader, PersonDetails> >("keymapper")); Assert.Null(observer.RetrieveMapper <ISourceMapper <Person, PersonDetails> >()); Assert.NotNull(observer.RetrieveMerger <ISourceMerger <IPersonHeader, PersonDetails> >()); Assert.NotNull(observer.RetrieveMerger <ISourceMerger <IPersonHeader, PersonDetails> >("merger")); Assert.Null(observer.RetrieveMerger <ISourceMerger <IPersonHeader, PersonDetails> >("merger1")); }
public void BuildAutoResolverMapperTest2() { TransformerObserver observer = new TransformerObserver(); Assert.IsTrue(observer.BuildAutoResolverMapper(typeof(User), typeof(UserDto))); User user1 = new User { Name = "name1", Surname = "surname1", Parent = new User { Name = "parteName1", Surname = "parentSurname1", Parent = new User { Name = "parentParentName1", Surname = "parentParentSurname1", Parent = new User() } } }; var res = observer.TryToMap <User, UserDto>(user1); Assert.IsNotNull(res); var res1 = observer.TryToMap(user1, typeof(UserDto)); Assert.IsNotNull(res1); }
public void RegisterMapperTest3() { TransformerObserver observer = new TransformerObserver(); IList <IPropertyMapper <Student, Person> > propMappers = new List <IPropertyMapper <Student, Person> > { new PropertyMapper <Student, Person>((student, person) => person.Name = student.Name, "Name", "Name") , new PropertyMapper <Student, Person>((student, person) => person.AnnoNascita = student.AnnoNascita) , new PropertyMapper <Student, Person>((student, person) => person.Parent = student.Father) }; ISourceMapper mapper1 = new SourceMapper <Student, Person>(propMappers, null, null); ISourceMapper <Student, Person> mapper2 = new SourceMapper <Student, Person>(propMappers, null, null); Assert.IsTrue(observer.BuildAutoResolverMapper <User, UserDto>(null, null)); //register a mapper which transfomr User into UserDto (1) Assert.IsTrue(observer.BuildAutoResolverMapper <Student, Person>(null, null)); //register a mapper which transfomr Student into Person (1) Assert.IsFalse(observer.RegisterMapper(mapper1)); // this mapper cannot be registered 'cause It was registered another similar mapper ( as (1) ) Assert.IsFalse(observer.RegisterMapper(mapper2)); // this mapper cannot be registered 'cause It was registered another similar mapper ( as (1) ) Assert.IsFalse(observer.BuildAutoResolverMapper <User, UserDto>(null, null)); //It's equals to mapper (1), so It cannot be registered. Assert.IsFalse(observer.BuildAutoResolverMapper <User, UserDto>(null, Console.WriteLine)); //It's similar to mapper (2), so It cannot be registered. Assert.IsTrue(observer.RegisterMapper(mapper1, KeyService.Type1)); // this mapper can be registered 'cause It was registered with another KeyService nevertheless using a similar mapper ( as (1) ) Assert.IsFalse(observer.RegisterMapper(mapper2, KeyService.Type1)); // this mapper cannot be registered 'cause It was registered another similar mapper ( as (1) ), using the same serviceKey like a previous registration. }
public void BuildAutoResolverMapperTest2() { TransformerObserver observer = new TransformerObserver(); Assert.IsTrue(observer.BuildAutoResolverMapper(typeof(User), typeof(UserDto))); User user1 = new User { Name = "name1", Surname = "surname1", Parent = new User { Name = "parteName1", Surname = "parentSurname1", Parent = new User { Name = "parentParentName1", Surname = "parentParentSurname1", Parent = new User() } } }; var res = observer.TryToMap<User, UserDto>(user1); Assert.IsNotNull(res); var res1 = observer.TryToMap(user1, typeof(UserDto)); Assert.IsNotNull(res1); }
public void RegisterMapperTest1() { TransformerObserver observer = new TransformerObserver(); IList <IPropertyMapper <Student, Person> > propMappers = new List <IPropertyMapper <Student, Person> > { new PropertyMapper <Student, Person>((student, person) => person.Name = student.Name, "Name", "Name") , new PropertyMapper <Student, Person>((student, person) => person.AnnoNascita = student.AnnoNascita) , new PropertyMapper <Student, Person>((student, person) => person.Parent = student.Father) }; SourceMapper <Student, Person> mapper1 = new SourceMapper <Student, Person>(propMappers, null, null); observer.RegisterMapper(mapper1); Student st = new Student { Name = "mario", Surname = "monti", AnnoNascita = 19 }; StudentDetails st2 = new StudentDetails { Name = "mario", Surname = "monti", AnnoNascita = 19, CF = "CF" }; var res = observer.TryToMap <Student, Person>(st); var res2 = observer.TryToMap <Student, Person>(st2); Assert.IsNotNull(res); Assert.IsNotNull(res2); }
//[Test] public void TestReflection() { TransformerObserver a = new TransformerObserver(); ITransformerResolver aa = a; ISourceMapper <Person, PersonaGiuridica> mapper0 = FactoryMapper.DynamicResolutionMapper <Person, PersonaGiuridica>(); SourceMapper <Person, PersonaGiuridica> mapper = new SourceMapper <Person, PersonaGiuridica>(new List <IPropertyMapper <Person, PersonaGiuridica> >(), null, null); //aa.Register<ISourceMapper<Person, PersonaGiuridica>>(mapper); //aa.Register(mapper0); object obj1 = new Person(); object obj2 = new Person(); Type t1 = typeof(IPersonHeader); Type t2 = typeof(Person); try { object instance = 5.5; //int i = (int) instance; byte bb = Convert.ToByte(instance); byte b = (byte)instance; double d = (double)instance; } catch (Exception) { Assert.IsFalse(true, "Cast invalid"); } Compare <IPersonHeader>(obj1, obj2); //Compare<long>(1, 10); }
public void MakeTransformerBuilderTest1() { TransformerObserver observer = new TransformerObserver(); var builder = observer.MakeTransformerBuilder <User, UserDto>(BuilderType.DefaultMappers); //builder.Include( // resolver => new PropertyMapper<User, UserDto>((user, dto) => dto.Parent = resolver.TryToMap<User, UserDto>(user.Parent))); builder.Include( resolver => new PropertyMapper <User, UserDto>((user, dto) => dto.Parent = (UserDto)resolver.TryToMap(user.Parent, typeof(UserDto)))); builder.BuildMapper(); User user1 = new User { Name = "name1", Surname = "surname1", Parent = new User { Name = "parteName1", Surname = "parentSurname1", Parent = new User { Name = "parentParentName1", Surname = "parentParentSurname1", Parent = new User() } } }; var resDto = observer.TryToMap <User, UserDto>(user1); Assert.IsNotNull(resDto); Assert.IsNotNull(resDto.Parent); var resDto1 = observer.TryToMap(user1, typeof(UserDto)); Assert.IsNotNull(resDto1); Assert.IsTrue(resDto1 is UserDto); Assert.IsNotNull(resDto1.GetType().GetProperty("Parent").GetValue(resDto1, null)); var resDto2 = observer.TryToMap <User, UserDto>(user1, "mykey"); Assert.IsNull(resDto2); var resDto3 = observer.TryToMap(user1, typeof(UserDto), "mykey"); Assert.IsNull(resDto3); }
public void BuildAutoResolverMapperTest3() { TransformerObserver observer = new TransformerObserver(); Assert.IsTrue(observer.BuildAutoResolverMapper(typeof(CustomComplexType), typeof(CustomComplexTypeDto))); Assert.IsTrue(observer.BuildAutoResolverMapper <User, UserDto>(null, null)); Assert.IsTrue(observer.RegisterMapper(new SimpleMapper <KeyService, KeyServiceOther>(service => (KeyServiceOther)Enum.ToObject(typeof(KeyServiceOther), service)))); CustomComplexType instance = new CustomComplexType { MyKeyService = KeyService.Type2, ComplexNaming = "complex_naming", Owner = new User { Name = "name1", Surname = "surname1", Parent = new User { Name = "parteName1", Surname = "parentSurname1", Parent = new User { Name = "parentParentName1", Surname = "parentParentSurname1", Parent = new User() } } } }; var res = observer.TryToMap <CustomComplexType, CustomComplexTypeDto>(instance); Assert.IsNotNull(res); Assert.AreEqual(res.MyKeyService, KeyServiceOther.Type2); Assert.AreEqual(res.ComplexNaming, instance.ComplexNaming); Assert.IsNotNull(res.Owner); var res1 = observer.TryToMap(instance, typeof(CustomComplexTypeDto)) as CustomComplexTypeDto; Assert.IsNotNull(res1); Assert.AreEqual(res1.MyKeyService, KeyServiceOther.Type2); Assert.AreEqual(res1.ComplexNaming, instance.ComplexNaming); Assert.IsNotNull(res1.Owner); var res2 = observer.TryToMap(KeyService.Type1, null); Assert.IsNull(res2); }
public void RegisterMapperTest2() { TransformerObserver observer = new TransformerObserver(); IList <IPropertyMapper <Student, Person> > propMappers = new List <IPropertyMapper <Student, Person> > { new PropertyMapper <Student, Person>((student, person) => person.Name = student.Name, "Name", "Name") , new PropertyMapper <Student, Person>((student, person) => person.AnnoNascita = student.AnnoNascita) , new PropertyMapper <Student, Person>((student, person) => person.Parent = student.Father) }; SourceMapper <Student, Person> mapper1 = new SourceMapper <Student, Person>(propMappers, null, null); Assert.IsTrue(observer.RegisterMapper(mapper1)); Assert.IsTrue(observer.RegisterMapper(mapper1, KeyService.Type1)); Assert.IsTrue(observer.RegisterMapper(mapper1, KeyService.Type2)); Assert.IsFalse(observer.RegisterMapper(mapper1)); Assert.IsFalse(observer.RegisterMapper(mapper1, "default")); Student st = new Student { Name = "mario", Surname = "monti", AnnoNascita = 19 }; var res1 = observer.TryToMap <Student, Person>(st); Assert.IsNotNull(res1); var res11 = observer.TryToMap(st, typeof(Person)); Assert.IsTrue(res11 is Person); Assert.IsNotNull(res11); var res2 = observer.TryToMap(st, typeof(Person), KeyService.Type1); Assert.IsNotNull(res2); var res22 = observer.TryToMap(st, typeof(Person), KeyService.Type1); Assert.IsNotNull(res22); var res0 = observer.TryToMap(st, typeof(Person), KeyService.Type3); Assert.IsNull(res0); var res00 = observer.TryToMap <Student, Person>(st, KeyService.Type3); Assert.IsNull(res00); }
public void TestMapper() { TransformerObserver observer = new TransformerObserver(); ISourceMapper <Student, Person> mapper1 = FactoryMapper.DynamicResolutionMapper <Student, Person>(); observer.RegisterMapper(mapper1); Student st = new Student { Name = "mario", Surname = "monti", AnnoNascita = 19 }; var res = observer.TryToMap <Student, Person>(st); Assert.IsNotNull(res); Assert.AreEqual(st.Name, res.Name); Assert.AreEqual(st.Surname, res.Surname); Assert.IsNull(st.Father); Assert.IsNull(res.Parent); }
public void MakeTransformerBuilderTest3() { TransformerObserver observer = new TransformerObserver(); var mapper = observer.MakeTransformerBuilder <Person, Student>(BuilderType.DynamicResolver); /* * here It's possible to add / delete property mappers. */ // before using the mapper object, It's needed to build it in order to associate into TransformerObserver mapper.BuildMapper(); Assert.IsNotNull(mapper); Person ps = new Person { Name = "name", Surname = "surname", AnnoNascita = 1980, Parent = new Person { Name = "parent_name", Surname = "parent_surname" } }; var resDto = observer.TryToMap <Person, Student>(ps); Assert.IsNotNull(resDto); Assert.IsNull(resDto.Father); var resDto1 = observer.TryToMap(ps, typeof(Student)); Assert.IsNotNull(resDto1); Assert.IsNull(resDto1.GetType().GetProperty("Father").GetValue(resDto1, null)); Assert.IsTrue(resDto1 is Student); var resDto2 = observer.TryToMap <Person, Student>(ps, "mykey"); Assert.IsNull(resDto2); var resDto3 = observer.TryToMap(ps, typeof(Student), "mykey"); Assert.IsNull(resDto3); }
public void BuildAutoResolverMapperTest3() { TransformerObserver observer = new TransformerObserver(); Assert.IsTrue(observer.BuildAutoResolverMapper(typeof(CustomComplexType), typeof(CustomComplexTypeDto))); Assert.IsTrue(observer.BuildAutoResolverMapper<User, UserDto>(null, null)); Assert.IsTrue(observer.RegisterMapper(new SimpleMapper<KeyService, KeyServiceOther>(service => (KeyServiceOther)Enum.ToObject(typeof(KeyServiceOther), service)))); CustomComplexType instance = new CustomComplexType { MyKeyService = KeyService.Type2, ComplexNaming = "complex_naming", Owner = new User { Name = "name1", Surname = "surname1", Parent = new User { Name = "parteName1", Surname = "parentSurname1", Parent = new User { Name = "parentParentName1", Surname = "parentParentSurname1", Parent = new User() } } } }; var res = observer.TryToMap<CustomComplexType, CustomComplexTypeDto>(instance); Assert.IsNotNull(res); Assert.AreEqual(res.MyKeyService, KeyServiceOther.Type2); Assert.AreEqual(res.ComplexNaming, instance.ComplexNaming); Assert.IsNotNull(res.Owner); var res1 = observer.TryToMap(instance, typeof(CustomComplexTypeDto)) as CustomComplexTypeDto; Assert.IsNotNull(res1); Assert.AreEqual(res1.MyKeyService, KeyServiceOther.Type2); Assert.AreEqual(res1.ComplexNaming, instance.ComplexNaming); Assert.IsNotNull(res1.Owner); var res2 = observer.TryToMap(KeyService.Type1, null); Assert.IsNull(res2); }
public void MakeTransformerBuilderTest4() { TransformerObserver observer = new TransformerObserver(); var mapper = observer.MakeTransformerBuilder <Person, Student>(BuilderType.DynamicResolver); mapper.Include(new PropertyMapper <Person, Student>((person, student) => student.Father = person.Parent, "Father", "Parent")); mapper.BuildMapper(); Assert.IsNotNull(mapper); Person ps = new Person { Name = "name", Surname = "surname", AnnoNascita = 1980, Parent = new Person { Name = "parent_name", Surname = "parent_surname" } }; var resDto = observer.TryToMap <Person, Student>(ps); Assert.IsNotNull(resDto); Assert.IsNotNull(resDto.Father); var resDto1 = observer.TryToMap(ps, typeof(Student)); Assert.IsNotNull(resDto1); Assert.IsNotNull(resDto1.GetType().GetProperty("Father").GetValue(resDto1, null)); Assert.IsTrue(resDto1 is Student); var resDto2 = observer.TryToMap <Person, Student>(ps, "mykey"); Assert.IsNull(resDto2); var resDto3 = observer.TryToMap(ps, typeof(Student), "mykey"); var resDto4 = observer.TryToMap(ps, null, "mykey"); Assert.IsNull(resDto3); Assert.IsNull(resDto4); }
public void TestOnBasePropertiesInterface() { TransformerObserver observer = new TransformerObserver(); observer.BuildAutoResolverMapper <IClassC, Demo2>(null, null); Demo1 demo = new Demo1 { MyAProp = "myprop1", MyBProp = "myprop2", MyBBProp = "myprop3", MyCProp = "myprop4" }; var res = observer.TryToMap <IClassC, Demo2>(demo); Assert.AreEqual(demo.MyAProp, res.MyAProp); Assert.AreEqual(demo.MyBProp, res.MyBProp); Assert.AreEqual(demo.MyBBProp, res.MyBBProp); Assert.AreEqual(demo.MyCProp, res.MyCProp); }
public void RegisterSimpleMapperTest1() { TransformerObserver observer = new TransformerObserver(); var mapper = new SimpleMapper <int?, int>(i => i.HasValue ? i.Value : 0); Assert.IsTrue(observer.RegisterMapper(mapper)); var res = observer.TryToMap <int?, int>(5); Assert.AreEqual(res, 5); var mapper1 = new SimpleMapper <KeyService, KeyServiceOther>( service => (KeyServiceOther)Enum.ToObject(typeof(KeyServiceOther), service)); Assert.IsTrue(observer.RegisterMapper(mapper1)); var res1 = observer.TryToMap <KeyService, KeyServiceOther>(KeyService.Type2); Assert.AreEqual(res1, KeyServiceOther.Type2); var res2 = observer.TryToMap <KeyService, KeyServiceOther>(KeyService.Type3); Assert.AreEqual(res2, KeyServiceOther.Type3); }
public void TestOnBasePropertiesInterface() { TransformerObserver observer = new TransformerObserver(); observer.BuildAutoResolverMapper<IClassC, Demo2>(null, null); Demo1 demo = new Demo1 { MyAProp = "myprop1", MyBProp = "myprop2", MyBBProp = "myprop3", MyCProp = "myprop4" }; var res = observer.TryToMap<IClassC, Demo2>(demo); Assert.AreEqual(demo.MyAProp, res.MyAProp); Assert.AreEqual(demo.MyBProp, res.MyBProp); Assert.AreEqual(demo.MyBBProp, res.MyBBProp); Assert.AreEqual(demo.MyCProp, res.MyCProp); }
public void RetreiveMapperFromObserver() { TransformerObserver observer = new TransformerObserver(); var builder = observer.MakeTransformerBuilder<IPersonHeader, PersonDetails>(BuilderType.DefaultMappers); var mapper1 = builder.BuildMapper(); var mapper2 = builder.BuildMapper("keymapper"); builder.BuildMerger(); builder.BuildMerger("merger"); Assert.IsNotNull(builder); Assert.AreEqual(mapper1, mapper2); Assert.AreNotSame(mapper1, mapper2); //IPersonHeader ps = new Person { Name = "name", Surname = "surname", AnnoNascita = 1980, Parent = null }; Assert.NotNull(observer.RetrieveMapper<ISourceMapper<IPersonHeader, PersonDetails>>()); Assert.Null(observer.RetrieveMapper<ISourceMapper<IPersonHeader, PersonDetails>>("mykey")); Assert.NotNull(observer.RetrieveMapper<ISourceMapper<IPersonHeader, PersonDetails>>("keymapper")); Assert.Null(observer.RetrieveMapper<ISourceMapper<Person, PersonDetails>>()); Assert.NotNull(observer.RetrieveMerger<ISourceMerger<IPersonHeader, PersonDetails>>()); Assert.NotNull(observer.RetrieveMerger<ISourceMerger<IPersonHeader, PersonDetails>>("merger")); Assert.Null(observer.RetrieveMerger<ISourceMerger<IPersonHeader, PersonDetails>>("merger1")); }
public void TestMapper() { TransformerObserver observer = new TransformerObserver(); ISourceMapper<Student, Person> mapper1 = FactoryMapper.DynamicResolutionMapper<Student, Person>(); observer.RegisterMapper(mapper1); Student st = new Student { Name = "mario", Surname = "monti", AnnoNascita = 19 }; var res = observer.TryToMap<Student, Person>(st); Assert.IsNotNull(res); Assert.AreEqual(st.Name, res.Name); Assert.AreEqual(st.Surname, res.Surname); Assert.IsNull(st.Father); Assert.IsNull(res.Parent); }
public void RegisterMapperTest3() { TransformerObserver observer = new TransformerObserver(); IList<IPropertyMapper<Student, Person>> propMappers = new List<IPropertyMapper<Student, Person>> { new PropertyMapper<Student, Person>( (student, person) => person.Name = student.Name, "Name", "Name") ,new PropertyMapper<Student, Person>( (student, person) => person.AnnoNascita = student.AnnoNascita ) ,new PropertyMapper<Student, Person>( (student, person) => person.Parent = student.Father ) }; ISourceMapper mapper1 = new SourceMapper<Student, Person>(propMappers, null, null); ISourceMapper<Student, Person> mapper2 = new SourceMapper<Student, Person>(propMappers, null, null); Assert.IsTrue(observer.BuildAutoResolverMapper<User, UserDto>(null, null)); //register a mapper which transfomr User into UserDto (1) Assert.IsTrue(observer.BuildAutoResolverMapper<Student, Person>(null, null)); //register a mapper which transfomr Student into Person (1) Assert.IsFalse(observer.RegisterMapper(mapper1)); // this mapper cannot be registered 'cause It was registered another similar mapper ( as (1) ) Assert.IsFalse(observer.RegisterMapper(mapper2)); // this mapper cannot be registered 'cause It was registered another similar mapper ( as (1) ) Assert.IsFalse(observer.BuildAutoResolverMapper<User, UserDto>(null, null)); //It's equals to mapper (1), so It cannot be registered. Assert.IsFalse(observer.BuildAutoResolverMapper<User, UserDto>(null, Console.WriteLine)); //It's similar to mapper (2), so It cannot be registered. Assert.IsTrue(observer.RegisterMapper(mapper1, KeyService.Type1)); // this mapper can be registered 'cause It was registered with another KeyService nevertheless using a similar mapper ( as (1) ) Assert.IsFalse(observer.RegisterMapper(mapper2, KeyService.Type1)); // this mapper cannot be registered 'cause It was registered another similar mapper ( as (1) ), using the same serviceKey like a previous registration. }
public void RegisterSimpleMapperTest1() { TransformerObserver observer = new TransformerObserver(); var mapper = new SimpleMapper<int?, int>(i => i.HasValue ? i.Value : 0); Assert.IsTrue(observer.RegisterMapper(mapper)); var res = observer.TryToMap<int?, int>(5); Assert.AreEqual(res, 5); var mapper1 = new SimpleMapper<KeyService, KeyServiceOther>( service => (KeyServiceOther)Enum.ToObject(typeof(KeyServiceOther), service)); Assert.IsTrue(observer.RegisterMapper(mapper1)); var res1 = observer.TryToMap<KeyService, KeyServiceOther>(KeyService.Type2); Assert.AreEqual(res1, KeyServiceOther.Type2); var res2 = observer.TryToMap<KeyService, KeyServiceOther>(KeyService.Type3); Assert.AreEqual(res2, KeyServiceOther.Type3); }
public void RegisterMapperTest1() { TransformerObserver observer = new TransformerObserver(); IList<IPropertyMapper<Student, Person>> propMappers = new List<IPropertyMapper<Student, Person>> { new PropertyMapper<Student, Person>( (student, person) => person.Name = student.Name, "Name", "Name") ,new PropertyMapper<Student, Person>( (student, person) => person.AnnoNascita = student.AnnoNascita ) ,new PropertyMapper<Student, Person>( (student, person) => person.Parent = student.Father ) }; SourceMapper<Student, Person> mapper1 = new SourceMapper<Student, Person>(propMappers, null, null); observer.RegisterMapper(mapper1); Student st = new Student { Name = "mario", Surname = "monti", AnnoNascita = 19 }; StudentDetails st2 = new StudentDetails { Name = "mario", Surname = "monti", AnnoNascita = 19, CF = "CF"}; var res = observer.TryToMap<Student, Person>(st); var res2 = observer.TryToMap<Student, Person>(st2); Assert.IsNotNull(res); Assert.IsNotNull(res2); }
public void RegisterMapperTest2() { TransformerObserver observer = new TransformerObserver(); IList<IPropertyMapper<Student, Person>> propMappers = new List<IPropertyMapper<Student, Person>> { new PropertyMapper<Student, Person>( (student, person) => person.Name = student.Name, "Name", "Name") ,new PropertyMapper<Student, Person>( (student, person) => person.AnnoNascita = student.AnnoNascita ) ,new PropertyMapper<Student, Person>( (student, person) => person.Parent = student.Father ) }; SourceMapper<Student, Person> mapper1 = new SourceMapper<Student, Person>(propMappers, null, null); Assert.IsTrue(observer.RegisterMapper(mapper1)); Assert.IsTrue(observer.RegisterMapper(mapper1, KeyService.Type1)); Assert.IsTrue(observer.RegisterMapper(mapper1, KeyService.Type2)); Assert.IsFalse(observer.RegisterMapper(mapper1)); Assert.IsFalse(observer.RegisterMapper(mapper1, "default")); Student st = new Student { Name = "mario", Surname = "monti", AnnoNascita = 19 }; var res1 = observer.TryToMap<Student, Person>(st); Assert.IsNotNull(res1); var res11 = observer.TryToMap(st, typeof(Person)); Assert.IsTrue(res11 is Person); Assert.IsNotNull(res11); var res2 = observer.TryToMap(st, typeof(Person), KeyService.Type1); Assert.IsNotNull(res2); var res22 = observer.TryToMap(st, typeof (Person), KeyService.Type1); Assert.IsNotNull(res22); var res0 = observer.TryToMap(st, typeof (Person), KeyService.Type3); Assert.IsNull(res0); var res00 = observer.TryToMap<Student, Person>(st, KeyService.Type3); Assert.IsNull(res00); }
public void MakeTransformerBuilderTest4() { TransformerObserver observer = new TransformerObserver(); var mapper = observer.MakeTransformerBuilder<Person, Student>(BuilderType.DynamicResolver); mapper.Include(new PropertyMapper<Person, Student>((person, student) => student.Father = person.Parent, "Father", "Parent")); mapper.BuildMapper(); Assert.IsNotNull(mapper); Person ps = new Person { Name = "name", Surname = "surname", AnnoNascita = 1980, Parent = new Person { Name = "parent_name", Surname = "parent_surname" } }; var resDto = observer.TryToMap<Person, Student>(ps); Assert.IsNotNull(resDto); Assert.IsNotNull(resDto.Father); var resDto1 = observer.TryToMap(ps, typeof(Student)); Assert.IsNotNull(resDto1); Assert.IsNotNull(resDto1.GetType().GetProperty("Father").GetValue(resDto1, null)); Assert.IsTrue(resDto1 is Student); var resDto2 = observer.TryToMap<Person, Student>(ps, "mykey"); Assert.IsNull(resDto2); var resDto3 = observer.TryToMap(ps, typeof(Student), "mykey"); var resDto4 = observer.TryToMap(ps, null, "mykey"); Assert.IsNull(resDto3); Assert.IsNull(resDto4); }
public void MakeTransformerBuilderTest3() { TransformerObserver observer = new TransformerObserver(); var mapper = observer.MakeTransformerBuilder<Person, Student>(BuilderType.DynamicResolver); /* * here It's possible to add / delete property mappers. */ // before using the mapper object, It's needed to build it in order to associate into TransformerObserver mapper.BuildMapper(); Assert.IsNotNull(mapper); Person ps = new Person { Name = "name", Surname = "surname", AnnoNascita = 1980, Parent = new Person { Name = "parent_name", Surname = "parent_surname" } }; var resDto = observer.TryToMap<Person, Student>(ps); Assert.IsNotNull(resDto); Assert.IsNull(resDto.Father); var resDto1 = observer.TryToMap(ps, typeof(Student)); Assert.IsNotNull(resDto1); Assert.IsNull(resDto1.GetType().GetProperty("Father").GetValue(resDto1, null)); Assert.IsTrue(resDto1 is Student); var resDto2 = observer.TryToMap<Person, Student>(ps, "mykey"); Assert.IsNull(resDto2); var resDto3 = observer.TryToMap(ps, typeof(Student), "mykey"); Assert.IsNull(resDto3); }
public void MakeTransformerBuilderTest2() { TransformerObserver observer = new TransformerObserver(); var mapper = observer.MakeTransformerBuilder<IPersonHeader, PersonDetails>(BuilderType.DefaultMappers); mapper.BuildMapper(); Assert.IsNotNull(mapper); IPersonHeader ps = new Person { Name = "name", Surname = "surname", AnnoNascita = 1980, Parent = null }; var resDto = observer.TryToMap<IPersonHeader, PersonDetails>(ps); Assert.IsNotNull(resDto); var resDto1 = observer.TryToMap(ps, typeof(PersonDetails)); Assert.IsNotNull(resDto1); Assert.IsTrue(resDto1 is PersonDetails); var resDto2 = observer.TryToMap<IPersonHeader, PersonDetails>(ps, "mykey"); Assert.IsNull(resDto2); var resDto3 = observer.TryToMap(ps, typeof(PersonDetails), "mykey"); Assert.IsNull(resDto3); }
public void MakeTransformerBuilderTest1() { TransformerObserver observer = new TransformerObserver(); var builder = observer.MakeTransformerBuilder<User, UserDto>(BuilderType.DefaultMappers); //builder.Include( // resolver => new PropertyMapper<User, UserDto>((user, dto) => dto.Parent = resolver.TryToMap<User, UserDto>(user.Parent))); builder.Include( resolver => new PropertyMapper<User, UserDto>((user, dto) => dto.Parent = (UserDto)resolver.TryToMap(user.Parent, typeof(UserDto)))); builder.BuildMapper(); User user1 = new User { Name = "name1", Surname = "surname1", Parent = new User { Name = "parteName1", Surname = "parentSurname1", Parent = new User { Name = "parentParentName1", Surname = "parentParentSurname1", Parent = new User() } } }; var resDto = observer.TryToMap<User, UserDto>(user1); Assert.IsNotNull(resDto); Assert.IsNotNull(resDto.Parent); var resDto1 = observer.TryToMap(user1, typeof (UserDto)); Assert.IsNotNull(resDto1); Assert.IsTrue(resDto1 is UserDto); Assert.IsNotNull(resDto1.GetType().GetProperty("Parent").GetValue(resDto1, null)); var resDto2 = observer.TryToMap<User, UserDto>(user1, "mykey"); Assert.IsNull(resDto2); var resDto3 = observer.TryToMap(user1, typeof(UserDto), "mykey"); Assert.IsNull(resDto3); }
public void BuildAutoResolverMapperTest5() { TransformerObserver observer = new TransformerObserver(); Assert.IsTrue(observer.BuildAutoResolverMapper(typeof(CustomSimpleTypeDto), typeof(CustomSimpleType))); Assert.IsTrue(observer.RegisterMapper(new SimpleMapper<int?, int>(i => i.GetValueOrDefault() ))); CustomSimpleTypeDto instance = new CustomSimpleTypeDto { Naming = "naming", Code = 10 }; var res = observer.TryToMap<CustomSimpleTypeDto, CustomSimpleType>(instance); Assert.IsNotNull(res); Assert.AreEqual(res.Naming, instance.Naming); Assert.AreEqual(res.Code, instance.Code); var res1 = observer.TryToMap(instance, typeof(CustomSimpleType)) as CustomSimpleType; Assert.IsNotNull(res1); Assert.AreEqual(res1.Naming, instance.Naming); Assert.AreEqual(res1.Code, instance.Code); }