Added integration tests for repository classes.

src/main/java/com/github/prominence/carrepair/model/domain/Order.java

@@ -36,7 +36,7 @@ public class Order {
     private BigDecimal totalPrice;
 
     @Column(name = "orderStatus", nullable = false)
-    private String orderStatus = OrderStatus.SCHEDULED.toString();
+    private String orderStatus = OrderStatus.SCHEDULED.toString(); // TODO: change to OrderStatus class
 
     public Order(String description, Client client, Mechanic mechanic, LocalDateTime createdOn, LocalDateTime finishedOn, BigDecimal totalPrice, String orderStatus) {
         this.description = description;

src/main/java/com/github/prominence/carrepair/repository/ClientRepository.java

@@ -12,5 +12,5 @@ import java.util.List;
 public interface ClientRepository extends JpaRepository<Client, Long> {
 
     @Query(value = "select c from Client c where c.firstName like concat('%', :query, '%') or c.middleName like concat('%', :query, '%') or c.lastName like concat('%', :query, '%')")
-    public List<Client> findAllByInitials(@Param(value = "query") String query);
+    List<Client> findAllByInitials(@Param(value = "query") String query);
 }

src/main/java/com/github/prominence/carrepair/repository/MechanicRepository.java

@@ -12,5 +12,5 @@ import java.util.List;
 public interface MechanicRepository extends JpaRepository<Mechanic, Long> {
 
     @Query(value = "select m from Mechanic m where m.firstName like concat('%', :query, '%') or m.middleName like concat('%', :query, '%') or m.lastName like concat('%', :query, '%')")
-    public List<Mechanic> findAllByInitials(@Param(value = "query") String query);
+    List<Mechanic> findAllByInitials(@Param(value = "query") String query);
 }

src/main/java/com/github/prominence/carrepair/repository/OrderRepository.java

@@ -10,5 +10,5 @@ import java.util.List;
 @Repository
 public interface OrderRepository extends JpaRepository<Order, Long>, JpaSpecificationExecutor<Order> {
 
-    public List<Order> findAllByMechanic_Id(Long id);
+    List<Order> findAllByMechanic_Id(Long id);
 }

src/test/java/com/github/prominence/carrepair/ClientRepositoryIntegrationTest.java

@@ -1,39 +0,0 @@
-package com.github.prominence.carrepair;
-
-import com.github.prominence.carrepair.model.domain.Client;
-import com.github.prominence.carrepair.repository.ClientRepository;
-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.autoconfigure.orm.jpa.TestEntityManager;
-import org.springframework.test.context.junit4.SpringRunner;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-@RunWith(SpringRunner.class)
-@DataJpaTest
-public class ClientRepositoryIntegrationTest {
-
-	@Autowired
-	private TestEntityManager entityManager;
-
-	@Autowired
-	private ClientRepository clientRepository;
-
-	@Test
-	public void whenFindById_thenReturnClient() {
-		// given
-		Client client = new Client("firstName", "middleName", "lastName", "123456789");
-		entityManager.persist(client);
-		entityManager.flush();
-
-		// when
-		Client found = clientRepository.findById(client.getId()).get();
-
-		// then
-		assertThat(found.hashCode()).isEqualTo(client.hashCode());
-	}
-
-}
-

src/test/java/com/github/prominence/carrepair/repository/ClientRepositoryIntegrationTest.java

@@ -0,0 +1,81 @@
+package com.github.prominence.carrepair.repository;
+
+import com.github.prominence.carrepair.model.domain.Client;
+import com.github.prominence.carrepair.repository.ClientRepository;
+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.autoconfigure.orm.jpa.TestEntityManager;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(SpringRunner.class)
+@DataJpaTest
+public class ClientRepositoryIntegrationTest {
+
+    @Autowired
+    private TestEntityManager entityManager;
+
+    @Autowired
+    private ClientRepository clientRepository;
+
+    @Test
+    public void whenFindById_thenReturnClient() {
+        // given
+        Client client = new Client("firstName", "middleName", "lastName", "123456789");
+        entityManager.persist(client);
+        entityManager.flush();
+
+        // when
+        Optional<Client> found = clientRepository.findById(client.getId());
+
+        // then
+        assertThat(found).isPresent().hasValue(client)
+                .map(Client::hashCode).get().isEqualTo(client.hashCode());
+    }
+
+    @Test
+    public void whenFindByWrongId_thenReturnNull() {
+        // when
+        Optional<Client> found = clientRepository.findById(-5L);
+
+        // then
+        assertThat(found).isNotPresent();
+    }
+
+    @Test
+    public void whenFindByInitials_thenReturnList() {
+        // given
+        Stream.of(
+                new Client("Alexey", "MiddleName", "Zinchenko", "12342312"),
+                new Client("John", "MiddleName", "Smith", "123123"),
+                new Client("Dirk", "Another", "Surname", "1231213")
+        ).forEach(entityManager::persist);
+        entityManager.flush();
+
+        // when
+        List<Client> clientsByMiddleName = clientRepository.findAllByInitials("Name");
+
+        // then
+        assertThat(clientsByMiddleName).size().isEqualTo(2);
+
+        // when
+        List<Client> clientsByNonExistingInfo = clientRepository.findAllByInitials("Ivan");
+
+        // then
+        assertThat(clientsByNonExistingInfo).isEmpty();
+
+        // when
+        List<Client> clientsByName = clientRepository.findAllByInitials("Alexey");
+
+        // then
+        assertThat(clientsByName).isNotEmpty().size().isEqualTo(1);
+    }
+}
+

src/test/java/com/github/prominence/carrepair/repository/MechanicRepositoryIntegrationTest.java

@@ -0,0 +1,80 @@
+package com.github.prominence.carrepair.repository;
+
+import com.github.prominence.carrepair.model.domain.Mechanic;
+import com.github.prominence.carrepair.repository.MechanicRepository;
+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.autoconfigure.orm.jpa.TestEntityManager;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import java.math.BigDecimal;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@DataJpaTest
+public class MechanicRepositoryIntegrationTest {
+    @Autowired
+    private TestEntityManager entityManager;
+
+    @Autowired
+    private MechanicRepository mechanicRepository;
+
+    @Test
+    public void whenFindById_thenReturnClient() {
+        // given
+        Mechanic mechanic = new Mechanic("firstName", "middleName", "lastName", BigDecimal.valueOf(12));
+        entityManager.persist(mechanic);
+        entityManager.flush();
+
+        // when
+        Optional<Mechanic> found = mechanicRepository.findById(mechanic.getId());
+
+        // then
+        assertThat(found).isPresent().hasValue(mechanic)
+                .map(Mechanic::hashCode).get().isEqualTo(mechanic.hashCode());
+    }
+
+    @Test
+    public void whenFindByWrongId_thenReturnNull() {
+        // when
+        Optional<Mechanic> found = mechanicRepository.findById(-5L);
+
+        // then
+        assertThat(found).isNotPresent();
+    }
+
+    @Test
+    public void whenFindByInitials_thenReturnList() {
+        // given
+        Stream.of(
+                new Mechanic("Alexey", "MiddleName", "Zinchenko", BigDecimal.valueOf(12)),
+                new Mechanic("John", "MiddleName", "Smith", BigDecimal.valueOf(25)),
+                new Mechanic("Dirk", "Another", "Surname", BigDecimal.valueOf(73))
+        ).forEach(entityManager::persist);
+        entityManager.flush();
+
+        // when
+        List<Mechanic> mechanicsByMiddleName = mechanicRepository.findAllByInitials("Name");
+
+        // then
+        assertThat(mechanicsByMiddleName).size().isEqualTo(2);
+
+        // when
+        List<Mechanic> mechanicsByNonExistingInfo = mechanicRepository.findAllByInitials("Ivan");
+
+        // then
+        assertThat(mechanicsByNonExistingInfo).isEmpty();
+
+        // when
+        List<Mechanic> clientsByName = mechanicRepository.findAllByInitials("Alexey");
+
+        // then
+        assertThat(clientsByName).isNotEmpty().size().isEqualTo(1);
+    }
+}

src/test/java/com/github/prominence/carrepair/repository/OrderRepositoryIntegrationTest.java

@@ -0,0 +1,89 @@
+package com.github.prominence.carrepair.repository;
+
+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 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.autoconfigure.orm.jpa.TestEntityManager;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@DataJpaTest
+public class OrderRepositoryIntegrationTest {
+    @Autowired
+    private TestEntityManager entityManager;
+
+    @Autowired
+    private OrderRepository orderRepository;
+
+    private Client testClient;
+    private Mechanic testMechanic;
+
+    @Before
+    public void setup() {
+        testClient = new Client("firstName", "middleName", "lastName", "123123123");
+        testMechanic = new Mechanic("firstNameM", "middleNameM", "lastNameM", BigDecimal.valueOf(231));
+
+        entityManager.persist(testClient);
+        entityManager.persist(testMechanic);
+        entityManager.flush();
+    }
+
+    @Test
+    public void whenFindById_thenReturnOrder() {
+        // given
+        Order order = new Order("someDescription", testClient, testMechanic, LocalDateTime.now(), null, BigDecimal.valueOf(233), OrderStatus.SCHEDULED.toString());
+        long orderKey = (Long) entityManager.persistAndGetId(order);
+        entityManager.flush();
+
+        // then
+        Optional<Order> foundOrder = orderRepository.findById(orderKey);
+
+        // then
+        assertThat(foundOrder).isPresent().map(Order::getId).get().isEqualTo(orderKey);
+    }
+
+    @Test
+    public void whenFindAllByMechanicId_thenReturnOrdersRelatedToProvidedMechanic() {
+        // given
+        List<Mechanic> tempMechanics = Arrays.asList(
+                new Mechanic("1", "1", "1", BigDecimal.valueOf(1)),
+                new Mechanic("2", "2", "2", BigDecimal.valueOf(2))
+        );
+        tempMechanics.forEach(entityManager::persist);
+
+        Stream.of(
+                new Order("testOrder", testClient, tempMechanics.get(0), LocalDateTime.now(), null, BigDecimal.valueOf(123), OrderStatus.DONE.toString()),
+                new Order("testOrder", testClient, tempMechanics.get(1), LocalDateTime.now(), null, BigDecimal.valueOf(123), OrderStatus.DONE.toString()),
+                new Order("testOrder", testClient, testMechanic, LocalDateTime.now(), null, BigDecimal.valueOf(123), OrderStatus.DONE.toString()),
+                new Order("testOrder", testClient, testMechanic, LocalDateTime.now(), null, BigDecimal.valueOf(123), OrderStatus.DONE.toString()),
+                new Order("testOrder", testClient, tempMechanics.get(0), LocalDateTime.now(), null, BigDecimal.valueOf(123), OrderStatus.DONE.toString()),
+                new Order("testOrder", testClient, testMechanic, LocalDateTime.now(), null, BigDecimal.valueOf(123), OrderStatus.DONE.toString()),
+                new Order("testOrder", testClient, tempMechanics.get(1), LocalDateTime.now(), null, BigDecimal.valueOf(123), OrderStatus.DONE.toString()),
+                new Order("testOrder", testClient, tempMechanics.get(1), LocalDateTime.now(), null, BigDecimal.valueOf(123), OrderStatus.DONE.toString())
+        ).forEach(entityManager::persist);
+        entityManager.flush();
+
+        // when
+        List<Order> foundOrders = orderRepository.findAllByMechanic_Id(testMechanic.getId());
+
+        // then
+        assertThat(foundOrders).size().isEqualTo(3);
+        assertThat(foundOrders).allMatch(order -> Objects.equals(order.getMechanic().getId(), testMechanic.getId()));
+    }
+}