@Test public void testSuperTypeConverterMapping() throws Exception { MapperFactory factory = MappingUtil.getMapperFactory(); factory.getConverterFactory().registerConverter(new XMLGregorianCalendarToDateConverter()); factory.build(); A a = new A(); Date date = new Date(); GregorianCalendar c = new GregorianCalendar(); c.setTime(date); a.setTime(DatatypeFactory.newInstance().newXMLGregorianCalendar(c)); B mapped = factory.getMapperFacade().map(a, B.class); assertNotNull(mapped); assertEquals(date, mapped.getTime()); }
@Test public void resolveConcreteClass() { MapperFacade mapper = factory.getMapperFacade(); factory.registerClassMap(ClassMapBuilder.map(ChildEntity.class, ChildDTO.class).byDefault().toClassMap()); factory.build(); ChildEntity entity = new ChildEntity(); entity.setId(1L); entity.setName("Khettabi"); BaseDTO dto = mapper.map(entity, BaseDTO.class); Assert.assertTrue(dto instanceof ChildDTO); Assert.assertEquals(entity.getName(), ((ChildDTO) dto).getName()); }
factory.registerClassMap(ClassMapBuilder.map(A.class, C.class).fieldMap("date").converter("dateConverter2").add().toClassMap()); factory.build();
@Test public void testDifferentLevelOfInheritance() { factory.registerClassMap(ClassMapBuilder.map(ChildEntity.class, Child2DTO.class) .customize(new MapperBase<ChildEntity, Child2DTO>() { @Override public void mapAtoB(ChildEntity a, Child2DTO b, MappingContext context) { b.setMessage("Hello " + a.getName()); } }).byDefault().toClassMap()); factory.build(); MapperFacade mapper = factory.getMapperFacade(); ChildEntity entity = new ChildEntity(); entity.setId(1L); entity.setName("Khettabi"); Child2DTO dto = mapper.map(entity, Child2DTO.class); Assert.assertEquals(entity.getId(), dto.getId()); Assert.assertEquals(entity.getName(), dto.getName()); Assert.assertEquals("Hello Khettabi", dto.getMessage()); }
@Before public void setUp() { mapperFactory = MappingUtil.getMapperFactory(); ClassMap<LineDTO, Line> classMap = ClassMapBuilder.map(LineDTO.class, Line.class).field("x0", "start.x").field("y0", "start.y") .field("x1", "end.x").field("y1", "end.y").toClassMap(); mapperFactory.registerClassMap(classMap); mapperFactory.build(); }
@Test public void testConvertLongString() { MapperFactory factory = MappingUtil.getMapperFactory(); factory.getConverterFactory().registerConverter(new LongToStringConverter()); factory.registerClassMap(ClassMapBuilder.map(A.class, B.class).field("id", "string").toClassMap()); factory.build(); A source = new A(); source.setId(42L); B destination = factory.getMapperFacade().map(source, B.class); Assert.assertEquals("42", destination.getString()); }
@Test public void testInverseOneToManyMapping() { MapperFactory mapperFactory = MappingUtil.getMapperFactory(); ClassMapBuilder<PublisherDTO, Publisher> classMapBuilder = ClassMapBuilder.map(PublisherDTO.class, Publisher.class); classMapBuilder.fieldMap("books").bInverse("publisher").add(); mapperFactory.registerClassMap(classMapBuilder.byDefault().toClassMap()); mapperFactory.build(); MapperFacade mapper = mapperFactory.getMapperFacade(); BookDTO parisNoirDTO = new BookDTO(); parisNoirDTO.setTitle("Paris Noir"); BookDTO chiensFousDTO = new BookDTO(); chiensFousDTO.setTitle("Chiens Fous"); PublisherDTO publisherDTO = new PublisherDTO(); publisherDTO.setName("Asphalte Editions"); publisherDTO.getBooks().add(parisNoirDTO); publisherDTO.getBooks().add(chiensFousDTO); Publisher publisher = mapper.map(publisherDTO, Publisher.class); Assert.assertTrue(publisher == publisher.getBooks().iterator().next().getPublisher()); }
@Test public void testPrimtiveToWrapper() { MapperFactory factory = MappingUtil.getMapperFactory(); factory.registerClassMap(ClassMapBuilder.map(Primitive.class, Wrapper.class).field("primitive", "wrapper").toClassMap()); factory.build(); MapperFacade mapper = factory.getMapperFacade(); Wrapper source = new Wrapper(); source.setWrapper(true); Primitive destination = mapper.map(source, Primitive.class); Assert.assertEquals(Boolean.TRUE, destination.isPrimitive()); }
@Test public void testWrapperToPrimtive() { MapperFactory factory = MappingUtil.getMapperFactory(); factory.registerClassMap(ClassMapBuilder.map(Wrapper.class, Primitive.class).field("wrapper", "primitive").toClassMap()); factory.build(); MapperFacade mapper = factory.getMapperFacade(); Primitive source = new Primitive(); source.setPrimitive(true); Wrapper destination = mapper.map(source, Wrapper.class); Assert.assertEquals(true, destination.getWrapper()); }
@Test public void testOneCallOfFieldMapping() { MapperFactory mapperFactory = MappingUtil.getMapperFactory(); { ClassMapBuilder<A, E> classMapBuilder = ClassMapBuilder.map(A.class, E.class); mapperFactory.registerClassMap(classMapBuilder.byDefault().toClassMap()); } { ClassMapBuilder<B, F> classMapBuilder = ClassMapBuilder.map(B.class, F.class); classMapBuilder.byDefault().use(A.class, E.class); mapperFactory.registerClassMap(classMapBuilder.toClassMap()); } mapperFactory.build(); MapperFacade mapperFacade = mapperFactory.getMapperFacade(); B source = new B(); source.setName("Israfil"); source.setAge(1000); F target = mapperFacade.map(source, F.class); Assert.assertEquals(source.getName(), target.getName()); Assert.assertEquals(source.getAge(), target.getAge()); Assert.assertEquals(1, target.getNameCalls()); }
@Test public void testReuseOfMapper() { MapperFactory mapperFactory = MappingUtil.getMapperFactory(); { ClassMapBuilder<A, C> classMapBuilder = ClassMapBuilder.map(A.class, C.class); classMapBuilder.field("name", "nom"); mapperFactory.registerClassMap(classMapBuilder.toClassMap()); } { ClassMapBuilder<B, D> classMapBuilder = ClassMapBuilder.map(B.class, D.class); classMapBuilder.field("age", "ages").use(A.class, C.class); mapperFactory.registerClassMap(classMapBuilder.toClassMap()); } mapperFactory.build(); MapperFacade mapperFacade = mapperFactory.getMapperFacade(); B source = new B(); source.setName("Israfil"); source.setAge(1000); D target = mapperFacade.map(source, D.class); Assert.assertEquals(source.getName(), target.getNom()); Assert.assertEquals(source.getAge(), target.getAges()); }
@Test public void testMappingByDefaultWithNoHint() throws Exception { MapperFactory factory = MappingUtil.getMapperFactory(); factory.registerClassMap(ClassMapBuilder.map(Library.class, LibraryMyDTO.class).byDefault().toClassMap()); factory.registerClassMap(ClassMapBuilder.map(Author.class, AuthorMyDTO.class).byDefault().toClassMap()); factory.registerClassMap(ClassMapBuilder.map(Book.class, BookMyDTO.class).byDefault().toClassMap()); factory.build(); MapperFacade mapper = factory.getMapperFacade(); Book book = createBook(BookParent.class); book.setAuthor(createAuthor(AuthorParent.class)); Library lib = createLibrary(LibraryParent.class); lib.getBooks().add(book); LibraryMyDTO mappedLib = mapper.map(lib, LibraryMyDTO.class); Assert.assertNotNull(mappedLib); Assert.assertTrue(mappedLib.getMyBooks().isEmpty()); }
@Test public void testInverseManyToOneMapping() { MapperFactory mapperFactory = MappingUtil.getMapperFactory(); ClassMapBuilder<BookDTO, Book> classMapBuilder = ClassMapBuilder.map(BookDTO.class, Book.class); classMapBuilder.fieldMap("author").bInverse("books").add(); mapperFactory.registerClassMap(classMapBuilder.byDefault().toClassMap()); mapperFactory.build(); MapperFacade mapper = mapperFactory.getMapperFacade(); AuthorDTO authorDTO = new AuthorDTO(); authorDTO.setFirstName("Khalil"); authorDTO.setLastName("Gibran"); BookDTO bookDTO = new BookDTO(); bookDTO.setTitle("The Prophet"); bookDTO.setAuthor(authorDTO); Book book = mapper.map(bookDTO, Book.class); Assert.assertTrue(book.getAuthor().getBooks().contains(book)); }
mapperFactory.build();
@Test public void testSimpleFieldMap() { ClassMap<Address, AddressDTO> classMap = ClassMapBuilder.map(Address.class, AddressDTO.class).field("country", "countryName") .field("city", "cityName").toClassMap(); MapperFactory factory = MappingUtil.getMapperFactory(); factory.registerClassMap(classMap); factory.build(); MapperFacade mapper = factory.getMapperFacade(); Address adress = new Address(); adress.setCountry("Morocco"); adress.setCity("Marrakesh"); AddressDTO adressDTO = mapper.map(adress, AddressDTO.class); Assert.assertEquals(adress.getCountry(), adressDTO.getCountryName()); Assert.assertEquals(adress.getCity(), adressDTO.getCityName()); }
factory.build();
@SuppressWarnings("deprecation") @Test public void testFail() { MapperFactory factory = new DefaultMapperFactory.Builder().build(); factory.registerClassMap(ClassMapBuilder.map(Base.class, BaseDto.class).customize(new MapperBase<Base, BaseDto>() { @Override public void mapAtoB(Base base, BaseDto baseDto, MappingContext context) { baseDto.setBaseField(base.getBaseTrickField()); } }).toClassMap()); factory.registerClassMap(ClassMapBuilder.map(Child.class, ChildDto.class).byDefault().toClassMap()); factory.build(); Child child = new Child(); child.setChildField("CHILD FIELD"); child.setBaseTrickField("BASE FIELD"); ChildDto dto = factory.getMapperFacade().map(child, ChildDto.class); Assert.assertNotNull(dto); Assert.assertEquals(child.getChildField(), dto.getChildField()); Assert.assertEquals(child.getBaseTrickField(), dto.getBaseField()); }
@Test public void testMapCamposEntradaToCamposSalida() throws Exception { CamposEntrada source = new CamposEntrada(); source.setId(5); source.setNumero(77); source.setOrden("ASC"); source.setPrefijo("2"); MapperFactory factory = new DefaultMapperFactory.Builder().build(); factory.registerClassMap(ClassMapBuilder .map(CamposEntrada.class, CamposSalida.class).byDefault() .toClassMap()); factory.build(); MapperFacade facade = factory.getMapperFacade(); CamposSalida result = facade.map(source, CamposSalida.class); Assert.assertEquals(result.getId(), source.getId()); Assert.assertEquals(result.getNumero(), ""+source.getNumero()); Assert.assertEquals(result.getOrden(), source.getOrden()); Assert.assertEquals(""+result.getPrefijo(), source.getPrefijo()); } }
@Test public void testMappingSubclassImplementationWithExistingMapping() throws Exception { MapperFactory factory = MappingUtil.getMapperFactory(); factory.registerClassMap(ClassMapBuilder.map(AuthorParent.class, AuthorMyDTO.class) .field("name", "myName") .byDefault() .toClassMap()); factory.registerClassMap(ClassMapBuilder.map(BookParent.class, BookMyDTO.class) .field("title", "myTitle") .field("author", "myAuthor") .byDefault() .toClassMap()); factory.build(); MapperFacade mapper = factory.getMapperFacade(); Book book = createBook(BookChild.class); book.setAuthor(createAuthor(AuthorChild.class)); BookMyDTO mappedBook = mapper.map(book, BookMyDTO.class); Assert.assertEquals(book.getTitle(), mappedBook.getMyTitle()); Assert.assertEquals(book.getAuthor().getName(), mappedBook.getMyAuthor().getMyName()); }
factory.build();