@Override public OrderDTO map(Order source) { return orderMapper.map(source); } };
@Override public T copy(F source) { checkNotNull(source, "source bean cannot be null!"); try { return copier.map(source); } catch (Exception e) { throw new CopierException("create object fail, class: " + targetClass.getName(), e); } }
@Override public void copy(F source, T target) { checkNotNull(source, "source bean cannot be null!"); checkNotNull(target, "target bean cannot be null!"); try { copier.map(source, target); } catch (Exception e) { throw new CopierException("create object fail, class: " + targetClass.getName(), e); } }
@Test public void test() { MapperFactory factory = MappingUtil.getMapperFactory(); configureMapperFactory(factory); Policy policy = new Policy(); Set<PolicyElement> elements = new HashSet<PolicyElement>(); elements.add(new CustomerElement()); elements.add(new ProductElement()); elements.add(new OtherElement()); elements.add(new OneOtherElement()); policy.setElements(elements); PolicyDTO dto = factory.getMapperFacade(Policy.class, PolicyDTO.class).map(policy); Assert.assertEquals(elements.size(), dto.getElements().size()); }
@Test public void testSimpleInheritance() { BoundMapperFacade<ChildEntity,ChildDTO> mapper = factory.getMapperFacade(ChildEntity.class, ChildDTO.class); ChildEntity entity = new ChildEntity(); entity.setId(1L); entity.setName("Khettabi"); ChildDTO dto = mapper.map(entity); Assert.assertEquals(entity.getId(), dto.getId()); Assert.assertEquals(entity.getName(), dto.getName()); }
@Test public void testArrayToList() { BoundMapperFacade<A, D> mapperFacade = MappingUtil.getMapperFactory().getMapperFacade(A.class, D.class); ArrayTestCaseClasses.A source = new ArrayTestCaseClasses.A(); byte[] buffer = new byte[]{1,2,3,4}; source.setBuffer(buffer); D destination = mapperFacade.map(source); Assert.assertEquals(Arrays.asList((byte)1,(byte)2,(byte)3,(byte)4), destination.getBuffer()); }
@Test public void testStringToString() { D source = new D(); source.setTags(Arrays.asList("soa", "java", "rest")); A destination = MappingUtil.getMapperFactory().getMapperFacade(D.class, A.class).map(source); Assert.assertNotNull(destination.getTags()); Assert.assertEquals(3, destination.getTags().size()); }
@Test public void testStringToStringWithGetterOnlyCollection() { D source = new D(); source.setTags(Arrays.asList("soa", "java", "rest")); B destination = MappingUtil.getMapperFactory().getMapperFacade(D.class, B.class).map(source); Assert.assertNotNull(destination.getTags()); Assert.assertEquals(3, destination.getTags().size()); }
@Test public void resolveConcreteClass() { BoundMapperFacade<ChildEntity,BaseDTO> mapper = factory.getMapperFacade(ChildEntity.class, BaseDTO.class); factory.registerClassMap(factory.classMap(ChildEntity.class, ChildDTO.class).byDefault()); ChildEntity entity = new ChildEntity(); entity.setId(1L); entity.setName("Khettabi"); BaseDTO dto = mapper.map(entity); Assert.assertTrue(dto instanceof ChildDTO); Assert.assertEquals(entity.getName(), ((ChildDTO) dto).getName()); }
@Test public void testDifferentLevelOfInheritance() { factory.registerClassMap(factory.classMap(ChildEntity.class, Child2DTO.class) .customize(new CustomMapper<ChildEntity, Child2DTO>() { public void mapAtoB(ChildEntity a, Child2DTO b, MappingContext context) { b.setMessage("Hello " + a.getName()); } }).byDefault()); BoundMapperFacade<ChildEntity,Child2DTO> mapper = factory.getMapperFacade(ChildEntity.class, Child2DTO.class); ChildEntity entity = new ChildEntity(); entity.setId(1L); entity.setName("Khettabi"); Child2DTO dto = mapper.map(entity); Assert.assertEquals(entity.getId(), dto.getId()); Assert.assertEquals(entity.getName(), dto.getName()); Assert.assertEquals("Hello Khettabi", dto.getMessage()); }
@Test public void testSimplePrimitiveToWrapperArray() { ArrayTestCaseClasses.A source = new ArrayTestCaseClasses.A(); byte[] buffer = new byte[]{1,2,3,4}; source.setBuffer(buffer); BoundMapperFacade<A,C> mapperFacade = MappingUtil.getMapperFactory().getMapperFacade(A.class, C.class); ArrayTestCaseClasses.C destination = mapperFacade.map(source); Assert.assertArrayEquals(new Byte[]{1,2,3,4}, destination.getBuffer()); }
@Test public void testSimplePrimitiveArray() { ArrayTestCaseClasses.A source = new ArrayTestCaseClasses.A(); byte[] buffer = new byte[]{1,2,3,4}; source.setBuffer(buffer); BoundMapperFacade<A,B> mapperFacade = MappingUtil.getMapperFactory().getMapperFacade(ArrayTestCaseClasses.A.class, ArrayTestCaseClasses.B.class); ArrayTestCaseClasses.B destination = mapperFacade.map(source); Assert.assertArrayEquals(source.getBuffer(), destination.getBuffer()); }
@Test public void testMappingArrayOfString() { Product p = new Product(); p.setTags(new String[] { "music", "sport" }); ProductDTO productDTO = MappingUtil.getMapperFactory().getMapperFacade(Product.class, ProductDTO.class).map(p); Assert.assertArrayEquals(p.getTags(), productDTO.getTags()); }
@Test public void testSuperTypeMappingForInaccessibleClasses() throws Exception { MapperFactory factory = MappingUtil.getMapperFactory(); Library lib = createLibrary(); Book book = lib.getBooks().get(0); LibraryDTO mappedLib = factory.getMapperFacade(Library.class, LibraryDTO.class).map(lib); Assert.assertNotNull(mappedLib); Assert.assertEquals(lib.getTitle(),mappedLib.getTitle()); Assert.assertEquals(book.getTitle(),mappedLib.getBooks().get(0).getTitle()); Assert.assertEquals(book.getAuthor().getName(),mappedLib.getBooks().get(0).getAuthor().getName()); }
person.setAge(31L); PersonVO vo = factory.getMapperFacade(Person.class, PersonVO.class).map(person);
@Test public void testNestedInheritance() { MapperFactory factory = MappingUtil.getMapperFactory(); factory.registerClassMap(factory.classMap(Person.class, PersonDTO.class).byDefault()); factory.registerClassMap(factory.classMap(Client.class, ClientDTO.class).byDefault()); factory.registerClassMap(factory.classMap(Subscription.class, SubscriptionDTO.class).field("client", "person")); Client client = new Client(); client.setName("Khalil Gebran"); Subscription subscription = new Subscription(); subscription.setClient(client); SubscriptionDTO dto = factory.getMapperFacade(Subscription.class, SubscriptionDTO.class).map(subscription); Assert.assertNotNull(dto); Assert.assertNotNull(dto.getPerson()); Assert.assertEquals(client.getName(), dto.getPerson().getName()); }
@Test public void testOneCallOfFieldMapping() { MapperFactory factory = MappingUtil.getMapperFactory(); { ClassMapBuilder<A, E> classMapBuilder = factory.classMap(A.class, E.class); factory.registerClassMap(classMapBuilder.byDefault().toClassMap()); } { ClassMapBuilder<B, F> classMapBuilder = factory.classMap(B.class, F.class); classMapBuilder.byDefault().use(A.class, E.class); factory.registerClassMap(classMapBuilder.toClassMap()); } BoundMapperFacade<B,F> mapperFacade = factory.getMapperFacade(B.class, F.class); B source = new B(); source.setName("Israfil"); source.setAge(1000); F target = mapperFacade.map(source); Assert.assertEquals(source.getName(), target.getName()); Assert.assertEquals(source.getAge(), target.getAge()); Assert.assertEquals(1, target.getNameCalls()); }
TaskLayer2<?> t2 = factory.getMapperFacade(TaskLayer1.class, TaskLayer2.class).map(t1); Assert.assertNotNull(t2); Assert.assertTrue(t1.getWorkers().containsAll(t2.getWorkers()));
@Test public void testFail() { MapperFactory factory = new DefaultMapperFactory.Builder().build(); factory.registerClassMap(factory.classMap(Base.class, BaseDto.class).customize(new CustomMapper<Base, BaseDto>() { @Override public void mapAtoB(Base base, BaseDto baseDto, MappingContext context) { baseDto.setBaseField(base.getBaseTrickField()); } }).toClassMap()); factory.registerClassMap(factory.classMap(Child.class, ChildDto.class).byDefault().toClassMap()); Child child = new Child(); child.setChildField("CHILD FIELD"); child.setBaseTrickField("BASE FIELD"); ChildDto dto = factory.getMapperFacade(Child.class, ChildDto.class).map(child); Assert.assertNotNull(dto); Assert.assertEquals(child.getChildField(), dto.getChildField()); Assert.assertEquals(child.getBaseTrickField(), dto.getBaseField()); }
@Test public void testBidirectionalMapping() { BoundMapperFacade<Book, BookDTO> mapper = MappingUtil.getMapperFactory().getMapperFacade(Book.class, BookDTO.class); Author author = new Author(); author.setFirstName("Khalil"); author.setLastName("Gibran"); Book book = new Book(); book.setTitle("The Prophet"); book.setAuthor(author); author.setBook(book); BookDTO dto = mapper.map(book); Assert.assertEquals(book.getTitle(), dto.getTitle()); Assert.assertEquals(book.getAuthor().getFirstName(), dto.getAuthor().getFirstName()); Assert.assertEquals(book.getAuthor().getLastName(), dto.getAuthor().getLastName()); Assert.assertTrue(dto == dto.getAuthor().getBook()); }