Added unit tests for mapper classes.

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);
         }

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<Client> 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<ClientDto> 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());
+    }
+}

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<Mechanic> 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<MechanicDto> 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());
+    }
+}

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<Order> 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<OrderDto> 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());
+    }
+}