diff --git a/src/main/java/com/github/prominence/carrepair/model/mapper/OrderMapper.java b/src/main/java/com/github/prominence/carrepair/model/mapper/OrderMapper.java index fb14c97..74c2807 100644 --- a/src/main/java/com/github/prominence/carrepair/model/mapper/OrderMapper.java +++ b/src/main/java/com/github/prominence/carrepair/model/mapper/OrderMapper.java @@ -47,6 +47,7 @@ public abstract class OrderMapper { @BeforeMapping protected void checkForEmptyStrings(OrderDto orderDto) { + if (orderDto == null) return; if (StringUtils.isEmpty(orderDto.getCreatedOnDate())) { orderDto.setCreatedOnDate(null); } diff --git a/src/test/java/com/github/prominence/carrepair/model/mapper/ClientMapperUnitTest.java b/src/test/java/com/github/prominence/carrepair/model/mapper/ClientMapperUnitTest.java new file mode 100644 index 0000000..72458bd --- /dev/null +++ b/src/test/java/com/github/prominence/carrepair/model/mapper/ClientMapperUnitTest.java @@ -0,0 +1,133 @@ +package com.github.prominence.carrepair.model.mapper; + +import com.github.prominence.carrepair.model.domain.Client; +import com.github.prominence.carrepair.model.dto.ClientDto; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mapstruct.factory.Mappers; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringRunner; + +import java.util.Arrays; +import java.util.List; + +import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; + +@RunWith(SpringRunner.class) +@ContextConfiguration +public class ClientMapperUnitTest { + + @Autowired + private ClientMapper clientMapper; + + @Configuration + public static class Config { + @Bean + public ClientMapper clientMapper() { + return Mappers.getMapper(ClientMapper.class); + } + } + + @Test + public void whenConvertClientToDto_thenReturnAppropriateClientDto() { + // given + Client client = new Client("1", "1", "1", "1"); + client.setId(5L); + + // when + ClientDto clientDto = clientMapper.clientToClientDto(client); + + // then + checkConformity(client, clientDto); + } + + @Test + public void whenConvertClientWithNullsToDto_thenReturnedDtoWillContainNulls() { + // given + Client client = new Client(null, "1", "1", null); + + // when + ClientDto clientDto = clientMapper.clientToClientDto(client); + + // then + checkConformity(client, clientDto); + } + + @Test + public void whenConvertClientDtoToClient_thenReturnAppropriateClient() { + //given + ClientDto clientDto = new ClientDto(); + clientDto.setId(4L); + clientDto.setFirstName("12"); + clientDto.setMiddleName("32"); + clientDto.setLastName("645"); + clientDto.setPhone("+123123"); + + // when + Client client = clientMapper.clientDtoToClient(clientDto); + + // then + checkConformity(client, clientDto); + } + + @Test + public void whenConvertClientDtoWithNullsToClient_thenReturnedClientWillContainNulls() { + //given + ClientDto clientDto = new ClientDto(); + clientDto.setFirstName("12"); + clientDto.setPhone("+123123"); + + // when + Client client = clientMapper.clientDtoToClient(clientDto); + + // then + checkConformity(client, clientDto); + } + + @Test + public void whenConvertClientListToClientDtoList_thenReturnDtoList() { + // given + List clientList = Arrays.asList( + new Client("1", "1", "1", "1"), + new Client("2", "2", "2", "2"), + new Client("3", "3", "3", "3"), + new Client("4", "4", "4", "4"), + new Client("5", "5", "5", "5"), + new Client("6", "6", "6", "6") + ); + + // when + List clientDtoList = clientMapper.clientsToClientDtoList(clientList); + + // then + for (int i = 0; i < clientList.size(); i++) { + checkConformity(clientList.get(i), clientDtoList.get(i)); + } + } + + @Test + public void whenConvertNullClient_thenReturnNullDto() { + assertThat(clientMapper.clientToClientDto(null)).isNull(); + } + + @Test + public void whenConvertNullClientDto_thenReturnNullClient() { + assertThat(clientMapper.clientDtoToClient(null)).isNull(); + } + + @Test + public void whenConvertNullClientList_thenReturnNullDtoList() { + assertThat(clientMapper.clientsToClientDtoList(null)).isNull(); + } + + private void checkConformity(Client client, ClientDto clientDto) { + assertThat(client.getId()).isEqualTo(clientDto.getId()); + assertThat(client.getFirstName()).isEqualTo(clientDto.getFirstName()); + assertThat(client.getMiddleName()).isEqualTo(clientDto.getMiddleName()); + assertThat(client.getLastName()).isEqualTo(clientDto.getLastName()); + assertThat(client.getPhoneNo()).isEqualTo(clientDto.getPhone()); + } +} diff --git a/src/test/java/com/github/prominence/carrepair/model/mapper/MechanicMapperUnitTest.java b/src/test/java/com/github/prominence/carrepair/model/mapper/MechanicMapperUnitTest.java new file mode 100644 index 0000000..ab83f91 --- /dev/null +++ b/src/test/java/com/github/prominence/carrepair/model/mapper/MechanicMapperUnitTest.java @@ -0,0 +1,134 @@ +package com.github.prominence.carrepair.model.mapper; + +import com.github.prominence.carrepair.model.domain.Mechanic; +import com.github.prominence.carrepair.model.dto.MechanicDto; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mapstruct.factory.Mappers; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringRunner; + +import java.math.BigDecimal; +import java.util.Arrays; +import java.util.List; + +import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; + +@RunWith(SpringRunner.class) +@ContextConfiguration +public class MechanicMapperUnitTest { + + @Autowired + private MechanicMapper mechanicMapper; + + @Configuration + public static class Config { + @Bean + public MechanicMapper mechanicMapper() { + return Mappers.getMapper(MechanicMapper.class); + } + } + + @Test + public void whenConvertMechanicToDto_thenReturnAppropriateMechanicDto() { + // given + Mechanic mechanic = new Mechanic("1", "1", "1", BigDecimal.ONE); + mechanic.setId(5L); + + // when + MechanicDto mechanicDto = mechanicMapper.mechanicToMechanicDto(mechanic); + + // then + checkConformity(mechanic, mechanicDto); + } + + @Test + public void whenConvertMechanicWithNullsToDto_thenReturnedDtoWillContainNulls() { + // given + Mechanic mechanic = new Mechanic(null, "1", "1", null); + + // when + MechanicDto mechanicDto = mechanicMapper.mechanicToMechanicDto(mechanic); + + // then + checkConformity(mechanic, mechanicDto); + } + + @Test + public void whenConvertMechanicDtoToMechanic_thenReturnAppropriateMechanic() { + //given + MechanicDto mechanicDto = new MechanicDto(); + mechanicDto.setId(4L); + mechanicDto.setFirstName("12"); + mechanicDto.setMiddleName("32"); + mechanicDto.setLastName("645"); + mechanicDto.setHourlyPayment(BigDecimal.TEN); + + // when + Mechanic mechanic = mechanicMapper.mechanicDtoToMechanic(mechanicDto); + + // then + checkConformity(mechanic, mechanicDto); + } + + @Test + public void whenConvertMechanicDtoWithNullsToMechanic_thenReturnedMechanicWillContainNulls() { + //given + MechanicDto mechanicDto = new MechanicDto(); + mechanicDto.setFirstName("12"); + mechanicDto.setHourlyPayment(BigDecimal.TEN); + + // when + Mechanic mechanic = mechanicMapper.mechanicDtoToMechanic(mechanicDto); + + // then + checkConformity(mechanic, mechanicDto); + } + + @Test + public void whenConvertMechanicListToMechanicDtoList_thenReturnDtoList() { + // given + List mechanicList = Arrays.asList( + new Mechanic("1", "1", "1", BigDecimal.ONE), + new Mechanic("2", "2", "2", BigDecimal.ONE), + new Mechanic("3", "3", "3", BigDecimal.ONE), + new Mechanic("4", "4", "4", BigDecimal.ONE), + new Mechanic("5", "5", "5", BigDecimal.ONE), + new Mechanic("6", "6", "6", BigDecimal.ONE) + ); + + // when + List mechanicDtoList = mechanicMapper.mechanicsToMechanicDtoList(mechanicList); + + // then + for (int i = 0; i < mechanicList.size(); i++) { + checkConformity(mechanicList.get(i), mechanicDtoList.get(i)); + } + } + + @Test + public void whenConvertNullMechanic_thenReturnNullDto() { + assertThat(mechanicMapper.mechanicToMechanicDto(null)).isNull(); + } + + @Test + public void whenConvertNullMechanicDto_thenReturnNullMechanic() { + assertThat(mechanicMapper.mechanicDtoToMechanic(null)).isNull(); + } + + @Test + public void whenConvertNullMechanicList_thenReturnNullDtoList() { + assertThat(mechanicMapper.mechanicsToMechanicDtoList(null)).isNull(); + } + + private void checkConformity(Mechanic mechanic, MechanicDto mechanicDto) { + assertThat(mechanic.getId()).isEqualTo(mechanicDto.getId()); + assertThat(mechanic.getFirstName()).isEqualTo(mechanicDto.getFirstName()); + assertThat(mechanic.getMiddleName()).isEqualTo(mechanicDto.getMiddleName()); + assertThat(mechanic.getLastName()).isEqualTo(mechanicDto.getLastName()); + assertThat(mechanic.getHourlyPayment()).isEqualTo(mechanicDto.getHourlyPayment()); + } +} diff --git a/src/test/java/com/github/prominence/carrepair/model/mapper/OrderMapperUnitTest.java b/src/test/java/com/github/prominence/carrepair/model/mapper/OrderMapperUnitTest.java new file mode 100644 index 0000000..c8b0d5e --- /dev/null +++ b/src/test/java/com/github/prominence/carrepair/model/mapper/OrderMapperUnitTest.java @@ -0,0 +1,187 @@ +package com.github.prominence.carrepair.model.mapper; + +import com.github.prominence.carrepair.enums.OrderStatus; +import com.github.prominence.carrepair.formatter.CustomDateTimeFormatter; +import com.github.prominence.carrepair.formatter.OrderStatusFormatter; +import com.github.prominence.carrepair.model.domain.Client; +import com.github.prominence.carrepair.model.domain.Mechanic; +import com.github.prominence.carrepair.model.domain.Order; +import com.github.prominence.carrepair.model.dto.OrderDto; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mapstruct.factory.Mappers; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.Import; +import org.springframework.context.i18n.LocaleContextHolder; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringRunner; + +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.util.Arrays; +import java.util.List; +import java.util.Locale; + +import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; + +@RunWith(SpringRunner.class) +@ContextConfiguration +@Import({OrderStatusFormatter.class, CustomDateTimeFormatter.class}) +public class OrderMapperUnitTest { + + @Autowired + private OrderMapper orderMapper; + + @Autowired + private OrderStatusFormatter orderStatusFormatter; + + @Autowired + private CustomDateTimeFormatter customDateTimeFormatter; + + @Configuration + public static class Config { + @Bean + public OrderMapper orderMapper() { + return Mappers.getMapper(OrderMapper.class); + } + } + + @Test + public void whenConvertOrderToDto_thenReturnAppropriateOrderDto() { + // given + Order order = new Order("", new Client(), new Mechanic(), LocalDateTime.now(), null, BigDecimal.TEN, OrderStatus.DONE.toString()); + order.setId(5L); + + // when + OrderDto orderDto = orderMapper.orderToOrderDto(order); + + // then + checkConformity(order, orderDto); + } + + @Test + public void whenConvertOrderWithNullsToDto_thenReturnedDtoWillContainNulls() { + // given + Order order = new Order(null, null, null, LocalDateTime.now(), null, BigDecimal.TEN, OrderStatus.SCHEDULED.toString()); + + // when + OrderDto orderDto = orderMapper.orderToOrderDto(order); + + // then + checkConformity(order, orderDto); + } + + @Test + public void whenConvertOrderDtoToOrder_thenReturnAppropriateOrder() { + //given + OrderDto orderDto = new OrderDto(); + orderDto.setId(4L); + orderDto.setMechanicId(3L); + orderDto.setMechanicFirstName("213"); + orderDto.setMechanicMiddleName("1231"); + orderDto.setMechanicLastName("qewqwe"); + orderDto.setClientId(4L); + orderDto.setClientFirstName("adsas"); + orderDto.setClientMiddleName("Sdas"); + orderDto.setClientLastName("asdasd"); + orderDto.setDescription("asdasdasdsad"); + orderDto.setTotalPrice(BigDecimal.TEN); + orderDto.setOrderStatus(OrderStatus.DONE.toString()); + orderDto.setCreatedOnDate(customDateTimeFormatter.print(LocalDateTime.now(), null)); + orderDto.setFinishedOnDate(customDateTimeFormatter.print(LocalDateTime.now().plusDays(1), null)); + + // when + Order order = orderMapper.orderDtoToOrder(orderDto); + + // then + checkConformity(order, orderDto); + } + + @Test + public void whenConvertOrderDtoWithNullsToOrder_thenReturnedOrderWillContainNulls() { + //given + OrderDto orderDto = new OrderDto(); + orderDto.setDescription("12"); + orderDto.setTotalPrice(BigDecimal.TEN); + orderDto.setOrderStatus(OrderStatus.SCHEDULED.toString()); + + // when + Order order = orderMapper.orderDtoToOrder(orderDto); + + // then + checkConformity(order, orderDto); + } + + @Test + public void whenConvertOrderListToOrderDtoList_thenReturnDtoList() { + // given + List orderList = Arrays.asList( + new Order("asdsa", new Client(), new Mechanic(), LocalDateTime.now(), LocalDateTime.now().plusHours(12), BigDecimal.TEN, OrderStatus.SCHEDULED.toString()), + new Order("asdsa", new Client(), new Mechanic(), LocalDateTime.now(), LocalDateTime.now().plusHours(12), BigDecimal.TEN, OrderStatus.SCHEDULED.toString()), + new Order("asdsa", new Client(), new Mechanic(), LocalDateTime.now(), LocalDateTime.now().plusHours(12), BigDecimal.TEN, OrderStatus.SCHEDULED.toString()), + new Order("asdsa", new Client(), new Mechanic(), LocalDateTime.now(), LocalDateTime.now().plusHours(12), BigDecimal.TEN, OrderStatus.SCHEDULED.toString()), + new Order("asdsa", new Client(), new Mechanic(), LocalDateTime.now(), LocalDateTime.now().plusHours(12), BigDecimal.TEN, OrderStatus.SCHEDULED.toString()), + new Order("asdsa", new Client(), new Mechanic(), LocalDateTime.now(), LocalDateTime.now().plusHours(12), BigDecimal.TEN, OrderStatus.SCHEDULED.toString()), + new Order("asdsa", new Client(), new Mechanic(), LocalDateTime.now(), LocalDateTime.now().plusHours(12), BigDecimal.TEN, OrderStatus.SCHEDULED.toString()) + ); + + // when + List orderDtoList = orderMapper.ordersToOrderDtoList(orderList); + + // then + for (int i = 0; i < orderList.size(); i++) { + checkConformity(orderList.get(i), orderDtoList.get(i)); + } + } + + @Test + public void whenConvertNullOrder_thenReturnNullDto() { + assertThat(orderMapper.orderToOrderDto(null)).isNull(); + } + + @Test + public void whenConvertNullOrderDto_thenReturnNullOrder() { + assertThat(orderMapper.orderDtoToOrder(null)).isNull(); + } + + @Test + public void whenConvertNullOrderList_thenReturnNullDtoList() { + assertThat(orderMapper.ordersToOrderDtoList(null)).isNull(); + } + + private void checkConformity(Order order, OrderDto orderDto) { + final Client client = order.getClient(); + final Mechanic mechanic = order.getMechanic(); + assertThat(order.getId()).isEqualTo(orderDto.getId()); + if (client == null) { + assertThat(orderDto.getClientId()).isNull(); + assertThat(orderDto.getClientFirstName()).isNull(); + assertThat(orderDto.getClientMiddleName()).isNull(); + assertThat(orderDto.getClientLastName()).isNull(); + } else { + assertThat(client.getId()).isEqualTo(orderDto.getClientId()); + assertThat(client.getFirstName()).isEqualTo(orderDto.getClientFirstName()); + assertThat(client.getMiddleName()).isEqualTo(orderDto.getClientMiddleName()); + assertThat(client.getLastName()).isEqualTo(orderDto.getClientLastName()); + } + if (mechanic == null) { + assertThat(orderDto.getMechanicId()).isNull(); + assertThat(orderDto.getMechanicFirstName()).isNull(); + assertThat(orderDto.getMechanicMiddleName()).isNull(); + assertThat(orderDto.getMechanicLastName()).isNull(); + } else { + assertThat(mechanic.getId()).isEqualTo(orderDto.getMechanicId()); + assertThat(mechanic.getFirstName()).isEqualTo(orderDto.getMechanicFirstName()); + assertThat(mechanic.getMiddleName()).isEqualTo(orderDto.getMechanicMiddleName()); + assertThat(mechanic.getLastName()).isEqualTo(orderDto.getMechanicLastName()); + } + final Locale locale = LocaleContextHolder.getLocale(); + assertThat(customDateTimeFormatter.print(order.getFinishedOn(), null)).isEqualTo(orderDto.getFinishedOnDate()); + assertThat(customDateTimeFormatter.print(order.getCreatedOn(), null)).isEqualTo(orderDto.getCreatedOnDate()); + assertThat(order.getDescription()).isEqualTo(orderDto.getDescription()); + assertThat(order.getOrderStatus()).isEqualTo(orderStatusFormatter.parse(orderDto.getOrderStatus(), locale)); + assertThat(order.getTotalPrice()).isEqualTo(orderDto.getTotalPrice()); + } +}