diff --git a/src/main/java/com/github/prominence/carrepair/repository/spec/OrderSpecifications.java b/src/main/java/com/github/prominence/carrepair/repository/spec/OrderSpecifications.java index cc44362..796d8c5 100644 --- a/src/main/java/com/github/prominence/carrepair/repository/spec/OrderSpecifications.java +++ b/src/main/java/com/github/prominence/carrepair/repository/spec/OrderSpecifications.java @@ -41,4 +41,8 @@ public class OrderSpecifications { return criteriaBuilder.and(predicates.toArray(new Predicate[0])); }; } + + public static Specification empty() { + return (root, criteriaQuery, criteriaBuilder) -> null; + } } diff --git a/src/main/java/com/github/prominence/carrepair/service/ClientService.java b/src/main/java/com/github/prominence/carrepair/service/ClientService.java index d88dfa0..c381888 100644 --- a/src/main/java/com/github/prominence/carrepair/service/ClientService.java +++ b/src/main/java/com/github/prominence/carrepair/service/ClientService.java @@ -59,6 +59,10 @@ public class ClientService { } } + public void deleteAll() { + clientRepository.deleteAll(); + } + public long getClientCount() { final long clientCount = clientRepository.count(); logger.trace("Found {} clients.", () -> clientCount); diff --git a/src/main/java/com/github/prominence/carrepair/service/MechanicService.java b/src/main/java/com/github/prominence/carrepair/service/MechanicService.java index 8556766..386bfc2 100644 --- a/src/main/java/com/github/prominence/carrepair/service/MechanicService.java +++ b/src/main/java/com/github/prominence/carrepair/service/MechanicService.java @@ -66,6 +66,10 @@ public class MechanicService { } } + public void deleteAll() { + mechanicRepository.deleteAll(); + } + public Map getOrderStatistics(Long mechanicId) { Map statistics = new HashMap<>(); statistics.put(OrderStatus.SCHEDULED, 0); diff --git a/src/main/java/com/github/prominence/carrepair/service/OrderService.java b/src/main/java/com/github/prominence/carrepair/service/OrderService.java index 96cb05f..dd8aba9 100644 --- a/src/main/java/com/github/prominence/carrepair/service/OrderService.java +++ b/src/main/java/com/github/prominence/carrepair/service/OrderService.java @@ -71,12 +71,17 @@ public class OrderService { } } + public void deleteAll() { + orderRepository.deleteAll(); + } + public long getOrderCount() { final long orderCount = orderRepository.count(); logger.trace("Found {} orders.", () -> orderCount); return orderCount; } + // TODO: check possible useless parameters public void fetchNestedObjectsAndValidate(OrderDto order, Long clientId, Long mechanicId, BindingResult bindingResult) { if (clientId != null) { logger.trace("Fetching Client[{}] for {}.", () -> clientId, () -> order); diff --git a/src/test/java/com/github/prominence/carrepair/repository/MechanicRepositoryIntegrationTest.java b/src/test/java/com/github/prominence/carrepair/repository/MechanicRepositoryIntegrationTest.java index 03812d7..4a7f60a 100644 --- a/src/test/java/com/github/prominence/carrepair/repository/MechanicRepositoryIntegrationTest.java +++ b/src/test/java/com/github/prominence/carrepair/repository/MechanicRepositoryIntegrationTest.java @@ -6,7 +6,7 @@ import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager; -import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; +import org.springframework.test.context.junit4.SpringRunner; import java.math.BigDecimal; import java.util.List; @@ -15,7 +15,7 @@ import java.util.stream.Stream; import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; -@RunWith(SpringJUnit4ClassRunner.class) +@RunWith(SpringRunner.class) @DataJpaTest public class MechanicRepositoryIntegrationTest { @Autowired diff --git a/src/test/java/com/github/prominence/carrepair/repository/OrderRepositoryIntegrationTest.java b/src/test/java/com/github/prominence/carrepair/repository/OrderRepositoryIntegrationTest.java index 9c575f6..e095ff2 100644 --- a/src/test/java/com/github/prominence/carrepair/repository/OrderRepositoryIntegrationTest.java +++ b/src/test/java/com/github/prominence/carrepair/repository/OrderRepositoryIntegrationTest.java @@ -10,7 +10,7 @@ import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager; -import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; +import org.springframework.test.context.junit4.SpringRunner; import java.math.BigDecimal; import java.time.LocalDateTime; @@ -22,7 +22,7 @@ import java.util.stream.Stream; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(SpringJUnit4ClassRunner.class) +@RunWith(SpringRunner.class) @DataJpaTest public class OrderRepositoryIntegrationTest { @Autowired diff --git a/src/test/java/com/github/prominence/carrepair/service/ClientServiceIntegrationTest.java b/src/test/java/com/github/prominence/carrepair/service/ClientServiceIntegrationTest.java new file mode 100644 index 0000000..888b121 --- /dev/null +++ b/src/test/java/com/github/prominence/carrepair/service/ClientServiceIntegrationTest.java @@ -0,0 +1,225 @@ +package com.github.prominence.carrepair.service; + +import com.github.prominence.carrepair.model.domain.Client; +import com.github.prominence.carrepair.model.dto.ClientDto; +import com.github.prominence.carrepair.model.mapper.ClientMapper; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import org.springframework.boot.test.mock.mockito.MockBean; +import org.springframework.context.annotation.Import; +import org.springframework.dao.DataIntegrityViolationException; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.PageRequest; +import org.springframework.test.context.junit4.SpringRunner; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; +import static org.mockito.Mockito.*; + +@RunWith(SpringRunner.class) +@DataJpaTest +@Import(ClientService.class) +public class ClientServiceIntegrationTest { + + @Autowired + private ClientService clientService; + + @MockBean + private ClientMapper clientMapper; + + @Before + public void setup() { + Arrays.asList( + new Client("1", "1", "1", "1"), + new Client("2", "2", "2", "2"), + new Client("3", "3", "3", "3") + ).forEach(clientService::save); + } + + @Test + public void whenSaveValidClient_thenHeWillBePersisted() { + // given + Client testClient = getTestClient(); + + // when + testClient = clientService.save(testClient); + + // then + assertThat(testClient.getId()).isPositive(); + } + + @Test(expected = DataIntegrityViolationException.class) + public void whenSaveInvalidClient_thenThrowAnException() { + // given + Client testClient = getTestClient(); + testClient.setFirstName(null); + + // expected exception + clientService.save(testClient); + } + + @Test + public void whenSaveValidClientDto_thenConvertToOClientAndSave() { + // given + ClientDto clientDto = new ClientDto(); + clientDto.setFirstName("1"); + clientDto.setMiddleName("1"); + clientDto.setLastName("1"); + clientDto.setPhone("1"); + + when(clientMapper.clientDtoToClient(clientDto)) + .thenReturn(new Client("1", "1", "1", "1")); + + // when + clientService.save(clientDto); + + // then + verify(clientMapper, times(1)).clientDtoToClient(clientDto); + } + + @Test(expected = DataIntegrityViolationException.class) + public void whenSaveInvalidClientDto_thenThrowAnException() { + // given + ClientDto clientDto = new ClientDto(); + + when(clientMapper.clientDtoToClient(clientDto)) + .thenReturn(new Client()); + + // expected exception + clientService.save(clientDto); + } + + @Test + public void whenFindAll_thenReturnAllSavedClients() { + assertThat(clientService.findAll(PageRequest.of(0, 10))).isNotEmpty(); + } + + @Test + public void whenFindById_thenReturnClientWithThisId() { + // given + Client testClient = getTestClient(); + + // when + Long testClientId = clientService.save(testClient).getId(); + Client returnedClient = clientService.findById(testClientId).get(); + + // then + assertThat(returnedClient).isNotNull(); + assertThat(returnedClient.getId()).isEqualTo(testClientId); + } + + @Test + public void whenGetClientCount_thenReturnPositiveClientCount() { + // when + Long clientCount = clientService.getClientCount(); + + // then + assertThat(clientCount).isPositive(); + } + + @Test + public void whenNoSavedClientsAndGetClientCount_thenReturnZero() { + // given + clientService.deleteAll(); + + // when + Long clientCount = clientService.getClientCount(); + + // then + assertThat(clientCount).isZero(); + } + + @Test + public void whenSearchByInitials_thenReturnAllThatMatches() { + // given + Arrays.asList( + new Client("John", "1", "Smith", "1"), + new Client("Ivan", "2", "Ivanov", "2"), + new Client("Alexey", "Ivanovich", "Smith", "3") + ).forEach(clientService::save); + + // when + List foundClients = clientService.searchByInitials("Ivan"); + + // then + assertThat(foundClients.size()).isEqualTo(2); + + // when + foundClients = clientService.searchByInitials("Smith"); + + // then + assertThat(foundClients.size()).isEqualTo(2); + + // when + foundClients = clientService.searchByInitials("Jo"); + + // then + assertThat(foundClients.size()).isEqualTo(1); + + // when + foundClients = clientService.searchByInitials("noone"); + + // then + assertThat(foundClients.size()).isZero(); + } + + @Test + public void whenDeleteClientById_thenHeWillBeDeleted() { + // given + Client testClient = getTestClient(); + + // when + Long savedClientId = clientService.save(testClient).getId(); + boolean wasDeleted = clientService.deleteClientById(savedClientId); + + // then + assertThat(wasDeleted).isTrue(); + assertThat(clientService.findById(savedClientId).isPresent()).isFalse(); + } + + @Test + public void whenConvertToDto_thenMapperIsParticipating() { + // given + Client testClient = getTestClient(); + + // when + clientService.convertToDto(testClient); + + // then + verify(clientMapper, times(1)).clientToClientDto(testClient); + } + + @Test + public void whenConvertClientPageToDtoPage_thenMapperIsParticipating() { + // given + Page clientPage = clientService.findAll(PageRequest.of(0, 10)); + + // when + clientService.convertToDtoPage(clientPage); + + // then + verify(clientMapper, times(1)).clientsToClientDtoList(clientPage.getContent()); + } + + @Test + public void whenConvertClientListToDtoList_thenMapperIsParticipating() { + // given + List clients = Collections.singletonList(getTestClient()); + + // when + clientService.convertToDtoList(clients); + + // then + verify(clientMapper, times(1)).clientsToClientDtoList(clients); + } + + private Client getTestClient() { + return new Client("firstName", "middleName", "lastName", "phoneNo"); + } +} diff --git a/src/test/java/com/github/prominence/carrepair/service/MechanicServiceIntegrationTest.java b/src/test/java/com/github/prominence/carrepair/service/MechanicServiceIntegrationTest.java new file mode 100644 index 0000000..d5fc9aa --- /dev/null +++ b/src/test/java/com/github/prominence/carrepair/service/MechanicServiceIntegrationTest.java @@ -0,0 +1,226 @@ +package com.github.prominence.carrepair.service; + +import com.github.prominence.carrepair.model.domain.Mechanic; +import com.github.prominence.carrepair.model.dto.MechanicDto; +import com.github.prominence.carrepair.model.mapper.MechanicMapper; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import org.springframework.boot.test.mock.mockito.MockBean; +import org.springframework.context.annotation.Import; +import org.springframework.dao.DataIntegrityViolationException; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.PageRequest; +import org.springframework.test.context.junit4.SpringRunner; + +import java.math.BigDecimal; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; +import static org.mockito.Mockito.*; + +@RunWith(SpringRunner.class) +@DataJpaTest +@Import(MechanicService.class) +public class MechanicServiceIntegrationTest { + + @Autowired + private MechanicService mechanicService; + + @MockBean + private MechanicMapper mechanicMapper; + + @Before + public void setup() { + Arrays.asList( + new Mechanic("1", "1", "1", BigDecimal.ONE), + new Mechanic("2", "2", "2", BigDecimal.TEN), + new Mechanic("3", "3", "3", BigDecimal.ONE.add(BigDecimal.ONE)) + ).forEach(mechanicService::save); + } + + @Test + public void whenSaveValidMechanic_thenHeWillBePersisted() { + // given + Mechanic testMechanic = getTestMechanic(); + + // when + testMechanic = mechanicService.save(testMechanic); + + // then + assertThat(testMechanic.getId()).isPositive(); + } + + @Test(expected = DataIntegrityViolationException.class) + public void whenSaveInvalidMechanic_thenThrowAnException() { + // given + Mechanic testMechanic = getTestMechanic(); + testMechanic.setFirstName(null); + + // expected exception + mechanicService.save(testMechanic); + } + + @Test + public void whenSaveMechanicDto_thenConvertToOMechanicAndSave() { + // given + MechanicDto mechanicDto = new MechanicDto(); + mechanicDto.setFirstName("1"); + mechanicDto.setMiddleName("1"); + mechanicDto.setLastName("1"); + mechanicDto.setHourlyPayment(BigDecimal.ONE); + + when(mechanicMapper.mechanicDtoToMechanic(mechanicDto)) + .thenReturn(new Mechanic("1", "1", "1", BigDecimal.ONE)); + + // when + mechanicService.save(mechanicDto); + + // then + verify(mechanicMapper, times(1)).mechanicDtoToMechanic(mechanicDto); + } + + @Test(expected = DataIntegrityViolationException.class) + public void whenSaveInvalidMechanicDto_thenThrowAnException() { + // given + MechanicDto mechanicDto = new MechanicDto(); + + when(mechanicMapper.mechanicDtoToMechanic(mechanicDto)) + .thenReturn(new Mechanic()); + + // expected exception + mechanicService.save(mechanicDto); + } + + @Test + public void whenFindAll_thenReturnAllSavedMechanics() { + assertThat(mechanicService.findAll(PageRequest.of(0, 10))).isNotEmpty(); + } + + @Test + public void whenFindById_thenReturnMechanicWithThisId() { + // given + Mechanic testMechanic = getTestMechanic(); + + // when + Long testMechanicId = mechanicService.save(testMechanic).getId(); + Mechanic returnedMechanic = mechanicService.findById(testMechanicId).get(); + + // then + assertThat(returnedMechanic).isNotNull(); + assertThat(returnedMechanic.getId()).isEqualTo(testMechanicId); + } + + @Test + public void whenGetMechanicCount_thenReturnPositiveMechanicCount() { + // when + Long mechanicCount = mechanicService.getMechanicCount(); + + // then + assertThat(mechanicCount).isPositive(); + } + + @Test + public void whenNoSavedMechanicsAndGetMechanicCount_thenReturnZero() { + // given + mechanicService.deleteAll(); + + // when + Long mechanicCount = mechanicService.getMechanicCount(); + + // then + assertThat(mechanicCount).isZero(); + } + + @Test + public void whenSearchByInitials_thenReturnAllThatMatches() { + // given + Arrays.asList( + new Mechanic("John", "1", "Smith", BigDecimal.ONE), + new Mechanic("Ivan", "2", "Ivanov", BigDecimal.TEN), + new Mechanic("Alexey", "Ivanovich", "Smith", BigDecimal.TEN.add(BigDecimal.ONE)) + ).forEach(mechanicService::save); + + // when + List foundMechanics = mechanicService.searchByInitials("Ivan"); + + // then + assertThat(foundMechanics.size()).isEqualTo(2); + + // when + foundMechanics = mechanicService.searchByInitials("Smith"); + + // then + assertThat(foundMechanics.size()).isEqualTo(2); + + // when + foundMechanics = mechanicService.searchByInitials("Jo"); + + // then + assertThat(foundMechanics.size()).isEqualTo(1); + + // when + foundMechanics = mechanicService.searchByInitials("noone"); + + // then + assertThat(foundMechanics.size()).isZero(); + } + + @Test + public void whenDeleteMechanicById_thenHeWillBeDeleted() { + // given + Mechanic testMechanic = getTestMechanic(); + + // when + Long savedMechanicId = mechanicService.save(testMechanic).getId(); + boolean wasDeleted = mechanicService.deleteMechanicById(savedMechanicId); + + // then + assertThat(wasDeleted).isTrue(); + assertThat(mechanicService.findById(savedMechanicId).isPresent()).isFalse(); + } + + @Test + public void whenConvertToDto_thenMapperIsParticipating() { + // given + Mechanic testMechanic = getTestMechanic(); + + // when + mechanicService.convertToDto(testMechanic); + + // then + verify(mechanicMapper, times(1)).mechanicToMechanicDto(testMechanic); + } + + @Test + public void whenConvertMechanicPageToDtoPage_thenMapperIsParticipating() { + // given + Page mechanicPage = mechanicService.findAll(PageRequest.of(0, 10)); + + // when + mechanicService.convertToDtoPage(mechanicPage); + + // then + verify(mechanicMapper, times(1)).mechanicsToMechanicDtoList(mechanicPage.getContent()); + } + + @Test + public void whenConvertMechanicListToDtoList_thenMapperIsParticipating() { + // given + List mechanics = Collections.singletonList(getTestMechanic()); + + // when + mechanicService.convertToDtoList(mechanics); + + // then + verify(mechanicMapper, times(1)).mechanicsToMechanicDtoList(mechanics); + } + + private Mechanic getTestMechanic() { + return new Mechanic("firstName", "middleName", "lastName", BigDecimal.ONE.add(BigDecimal.ONE)); + } +} diff --git a/src/test/java/com/github/prominence/carrepair/service/OrderServiceIntegrationTest.java b/src/test/java/com/github/prominence/carrepair/service/OrderServiceIntegrationTest.java new file mode 100644 index 0000000..36eee5e --- /dev/null +++ b/src/test/java/com/github/prominence/carrepair/service/OrderServiceIntegrationTest.java @@ -0,0 +1,270 @@ +package com.github.prominence.carrepair.service; + +import com.github.prominence.carrepair.enums.OrderStatus; +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 com.github.prominence.carrepair.model.mapper.ClientMapper; +import com.github.prominence.carrepair.model.mapper.MechanicMapper; +import com.github.prominence.carrepair.model.mapper.OrderMapper; +import com.github.prominence.carrepair.repository.spec.OrderSpecifications; +import com.github.prominence.carrepair.validation.OrderValidator; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import org.springframework.boot.test.mock.mockito.MockBean; +import org.springframework.boot.test.mock.mockito.MockBeans; +import org.springframework.context.annotation.Import; +import org.springframework.dao.DataIntegrityViolationException; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.PageRequest; +import org.springframework.test.context.junit4.SpringRunner; +import org.springframework.validation.BindingResult; +import org.springframework.validation.SmartValidator; + +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.util.Arrays; + +import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; +import static org.mockito.Mockito.*; + +@RunWith(SpringRunner.class) +@DataJpaTest +@Import({OrderService.class, ClientService.class, MechanicService.class}) +@MockBeans({@MockBean(ClientMapper.class), @MockBean(MechanicMapper.class)}) +public class OrderServiceIntegrationTest { + + @Autowired + private OrderService orderService; + + @Autowired + private ClientService clientService; + + @Autowired + private MechanicService mechanicService; + + @MockBean + private SmartValidator smartValidator; + + @MockBean + private OrderValidator orderValidator; + + @MockBean + private OrderMapper orderMapper; + + private Order testOrder; + + @Before + public void setup() { + Client testClient = new Client("1", "1", "1", "1"); + clientService.save(testClient); + + Mechanic testMechanic = new Mechanic("1", "1", "1", BigDecimal.ONE); + mechanicService.save(testMechanic); + + testOrder = new Order("1", testClient, testMechanic, LocalDateTime.now(), null, BigDecimal.ONE, OrderStatus.SCHEDULED.toString()); + Arrays.asList( + testOrder, + new Order("2", testClient, testMechanic, LocalDateTime.now(), LocalDateTime.now().plusDays(1), BigDecimal.TEN, OrderStatus.ACCEPTED.toString()), + new Order("3", testClient, testMechanic, LocalDateTime.now(), LocalDateTime.now().plusHours(2), BigDecimal.TEN, OrderStatus.DONE.toString()) + ).forEach(orderService::save); + } + + @Test + public void whenSaveOrder_thenHeWillBePersisted() { + // given + Order testOrder = this.testOrder; + + // when + testOrder = orderService.save(testOrder); + + // then + assertThat(testOrder.getId()).isPositive(); + } + + @Test(expected = DataIntegrityViolationException.class) + public void whenSaveInvalidOrder_thenThrowAnException() { + // given + Order testOrder = new Order(); + + // expected exception + orderService.save(testOrder); + } + + @Test + public void whenSaveOrderDto_thenConvertToOrderAndSave() { + // given + OrderDto orderDto = getTestOrderDto(); + + when(orderMapper.orderDtoToOrder(orderDto)) + .thenReturn(new Order("123", this.testOrder.getClient(), this.testOrder.getMechanic(), LocalDateTime.now(), null, BigDecimal.TEN, OrderStatus.DONE.toString())); + + // when + orderService.save(orderDto); + + // then + verify(orderMapper, times(1)).orderDtoToOrder(orderDto); + } + + @Test(expected = DataIntegrityViolationException.class) + public void whenSaveInvalidOrderDto_thenThrowAnException() { + // given + OrderDto orderDto = new OrderDto(); + + when(orderMapper.orderDtoToOrder(orderDto)) + .thenReturn(new Order()); + + // expected exception + orderService.save(orderDto); + } + + @Test + public void whenFindAllWithoutSearchParameters_thenReturnAllSavedOrders() { + assertThat(orderService.findAll(OrderSpecifications.empty(), PageRequest.of(0, 10))).isNotEmpty(); + } + + @Test + public void whenFindAllWithSearchParameters_thenReturnAllMatches() { + // variables + final PageRequest pageable = PageRequest.of(0, 10); + + // when + Page foundOrders = orderService.findAll(OrderSpecifications.search(null, null, OrderStatus.DONE), pageable); + + // then + assertThat(foundOrders.getTotalElements()).isEqualTo(1); + + // when + foundOrders = orderService.findAll(OrderSpecifications.search("1", null, null), pageable); + + // then + assertThat(foundOrders.getTotalElements()).isEqualTo(3); + + // when + foundOrders = orderService.findAll(OrderSpecifications.search("444", null, null), pageable); + + // then + assertThat(foundOrders.getTotalElements()).isZero(); + + // when + foundOrders = orderService.findAll(OrderSpecifications.search("1", "1", OrderStatus.SCHEDULED), pageable); + + // then + assertThat(foundOrders.getTotalElements()).isEqualTo(1); + + // when + foundOrders = orderService.findAll(OrderSpecifications.search("1", "1", OrderStatus.DONE), pageable); + + // then + assertThat(foundOrders.getTotalElements()).isZero(); + } + + @Test + public void whenFindById_thenReturnMechanicWithThisId() { + // given + Order testOrder = this.testOrder; + + // when + Long testOrderId = orderService.save(testOrder).getId(); + Order returnedOrder = orderService.findById(testOrderId).get(); + + // then + assertThat(returnedOrder).isNotNull(); + assertThat(returnedOrder.getId()).isEqualTo(testOrderId); + } + + @Test + public void whenGetOrderCount_thenReturnPositiveOrderCount() { + // when + Long orderCount = orderService.getOrderCount(); + + // then + assertThat(orderCount).isPositive(); + } + + @Test + public void whenNoSavedOrdersAndGetOrderCount_thenReturnZero() { + // given + orderService.deleteAll(); + + // when + Long orderCount = orderService.getOrderCount(); + + // then + assertThat(orderCount).isZero(); + } + + @Test + public void whenDeleteOrderById_thenItWillBeDeleted() { + // given + Order testOrder = new Order("123", this.testOrder.getClient(), this.testOrder.getMechanic(), LocalDateTime.now(), null, BigDecimal.TEN, OrderStatus.DONE.toString()); + + // when + Long savedOrderId = orderService.save(testOrder).getId(); + boolean wasDeleted = orderService.deleteOrderById(savedOrderId); + + // then + assertThat(wasDeleted).isTrue(); + assertThat(orderService.findById(savedOrderId).isPresent()).isFalse(); + } + + @Test + public void whenConvertToDto_thenMapperIsParticipating() { + // given + Order testOrder = this.testOrder; + + // when + orderService.convertToDto(testOrder); + + // then + verify(orderMapper, times(1)).orderToOrderDto(testOrder); + } + + @Test + public void whenConvertOrderPageToDtoPage_thenMapperIsParticipating() { + // given + Page orderPage = orderService.findAll(OrderSpecifications.empty(), PageRequest.of(0, 10)); + + // when + orderService.convertToDtoPage(orderPage); + + // then + verify(orderMapper, times(1)).ordersToOrderDtoList(orderPage.getContent()); + } + + @Test + public void whenFetchNestedObjectsAndValidate_thenValidationMustBePerformed() { + // given + OrderDto orderDto = getTestOrderDto(); + final BindingResult bindingResult = mock(BindingResult.class); + + // when + orderService.fetchNestedObjectsAndValidate(orderDto, orderDto.getClientId(), orderDto.getMechanicId(), bindingResult); + + // then + verify(smartValidator, times(1)).validate(orderDto, bindingResult); + verify(orderValidator, times(1)).validate(orderDto, bindingResult); + } + + private OrderDto getTestOrderDto() { + OrderDto orderDto = new OrderDto(); + orderDto.setFinishedOnDate(null); + orderDto.setCreatedOnDate(LocalDateTime.now().toString()); + orderDto.setMechanicId(1L); + orderDto.setMechanicFirstName("1"); + orderDto.setMechanicMiddleName("1"); + orderDto.setMechanicLastName("1"); + orderDto.setClientId(1L); + orderDto.setClientFirstName("1"); + orderDto.setClientMiddleName("1"); + orderDto.setClientLastName("1"); + orderDto.setDescription("123"); + orderDto.setOrderStatus(OrderStatus.DONE.toString()); + orderDto.setTotalPrice(BigDecimal.TEN); + return orderDto; + } +}