Added integration tests for service classes.

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<Order> empty() {
+        return (root, criteriaQuery, criteriaBuilder) -> null;
+    }
 }

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

src/main/java/com/github/prominence/carrepair/service/MechanicService.java

@@ -66,6 +66,10 @@ public class MechanicService {
         }
     }
 
+    public void deleteAll() {
+        mechanicRepository.deleteAll();
+    }
+
     public Map<OrderStatus, Integer> getOrderStatistics(Long mechanicId) {
         Map<OrderStatus, Integer> statistics = new HashMap<>();
         statistics.put(OrderStatus.SCHEDULED, 0);

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

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

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

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

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

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