Merge branch 'master' into bael-16656

persistence-modules/spring-data-jpa/src/test/java/com/baeldung/boot/daos/ArticleRepositoryIntegrationTest.java

@@ -0,0 +1,67 @@
+package com.baeldung.boot.daos;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.List;
+
+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.test.context.junit4.SpringRunner;
+
+import com.baeldung.boot.domain.Article;
+
+@RunWith(SpringRunner.class)
+@DataJpaTest(properties="spring.datasource.data=classpath:import_entities.sql")
+public class ArticleRepositoryIntegrationTest {
+
+    @Autowired
+    private ArticleRepository repository;
+
+    @Test
+    public void givenImportedArticlesWhenFindAllByPublicationDateThenArticles1And2Returned()
+      throws Exception {
+        List<Article> result = repository.findAllByPublicationDate(
+          new SimpleDateFormat("yyyy-MM-dd").parse("2018-01-01")
+        );
+
+        assertEquals(2, result.size());
+        assertTrue(result.stream()
+          .map(Article::getId)
+          .allMatch(id -> Arrays.asList(1, 2).contains(id))
+        );
+    }
+
+    @Test
+    public void givenImportedArticlesWhenFindAllByPublicationTimeBetweenThenArticles2And3Returned()
+      throws Exception {
+        List<Article> result = repository.findAllByPublicationTimeBetween(
+          new SimpleDateFormat("HH:mm").parse("15:15"),
+          new SimpleDateFormat("HH:mm").parse("16:30")
+        );
+
+        assertEquals(2, result.size());
+        assertTrue(result.stream()
+          .map(Article::getId)
+          .allMatch(id -> Arrays.asList(2, 3).contains(id))
+        );
+    }
+
+    @Test
+    public void givenImportedArticlesWhenFindAllWithCreationDateTimeBeforeThenArticles2And3Returned() throws Exception {
+        List<Article> result = repository.findAllWithCreationDateTimeBefore(
+          new SimpleDateFormat("yyyy-MM-dd HH:mm").parse("2017-12-15 10:00")
+        );
+
+        assertEquals(2, result.size());
+        assertTrue(result.stream()
+          .map(Article::getId)
+          .allMatch(id -> Arrays.asList(2, 3).contains(id))
+        );
+    }
+
+}

persistence-modules/spring-data-jpa/src/test/java/com/baeldung/boot/daos/ExtendedStudentRepositoryIntegrationTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.boot.daos;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.List;
+
+import javax.annotation.Resource;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.boot.Application;
+import com.baeldung.boot.domain.Student;
+
+@RunWith(SpringRunner.class)
+@ContextConfiguration(classes = {Application.class})
+@DirtiesContext
+public class ExtendedStudentRepositoryIntegrationTest {
+    @Resource
+    private ExtendedStudentRepository extendedStudentRepository;
+
+    @Before
+    public void setup() {
+        Student student = new Student(1, "john");
+        extendedStudentRepository.save(student);
+        Student student2 = new Student(2, "johnson");
+        extendedStudentRepository.save(student2);
+        Student student3 = new Student(3, "tom");
+        extendedStudentRepository.save(student3);
+    }
+
+    @Test
+    public void givenStudents_whenFindByName_thenGetOk() {
+        List<Student> students = extendedStudentRepository.findByAttributeContainsText("name", "john");
+        assertThat(students.size()).isEqualTo(2);
+    }
+}

persistence-modules/spring-data-jpa/src/test/java/com/baeldung/boot/daos/InventoryRepositoryIntegrationTest.java

@@ -0,0 +1,61 @@
+package com.baeldung.boot.daos;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.math.BigDecimal;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.boot.Application;
+import com.baeldung.boot.domain.MerchandiseEntity;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes=Application.class)
+public class InventoryRepositoryIntegrationTest {
+
+    private static final String ORIGINAL_TITLE = "Pair of Pants";
+    private static final String UPDATED_TITLE = "Branded Luxury Pants";
+    private static final String UPDATED_BRAND = "Armani";
+    private static final String ORIGINAL_SHORTS_TITLE = "Pair of Shorts";
+
+    @Autowired
+    private InventoryRepository repository;
+
+    @Test
+    public void shouldCreateNewEntryInDB() {
+        MerchandiseEntity pants = new MerchandiseEntity(ORIGINAL_TITLE, BigDecimal.ONE);
+        pants = repository.save(pants);
+
+        MerchandiseEntity shorts = new MerchandiseEntity(ORIGINAL_SHORTS_TITLE, new BigDecimal(3));
+        shorts = repository.save(shorts);
+
+        assertNotNull(pants.getId());
+        assertNotNull(shorts.getId());
+        assertNotEquals(pants.getId(), shorts.getId());
+    }
+
+    @Test
+    public void shouldUpdateExistingEntryInDB() {
+        MerchandiseEntity pants = new MerchandiseEntity(ORIGINAL_TITLE, BigDecimal.ONE);
+        pants = repository.save(pants);
+
+        Long originalId = pants.getId();
+
+        pants.setTitle(UPDATED_TITLE);
+        pants.setPrice(BigDecimal.TEN);
+        pants.setBrand(UPDATED_BRAND);
+
+        MerchandiseEntity result = repository.save(pants);
+
+        assertEquals(originalId, result.getId());
+        assertEquals(UPDATED_TITLE, result.getTitle());
+        assertEquals(BigDecimal.TEN, result.getPrice());
+        assertEquals(UPDATED_BRAND, result.getBrand());
+    }
+}

persistence-modules/spring-data-jpa/src/test/java/com/baeldung/boot/daos/JpaRepositoriesIntegrationTest.java

@@ -0,0 +1,93 @@
+package com.baeldung.boot.daos;
+
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertFalse;
+import static junit.framework.TestCase.assertNotNull;
+import static junit.framework.TestCase.assertNull;
+import static junit.framework.TestCase.assertTrue;
+
+import java.util.List;
+import java.util.Optional;
+
+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.test.context.junit4.SpringRunner;
+
+import com.baeldung.boot.domain.Item;
+import com.baeldung.boot.domain.ItemType;
+import com.baeldung.boot.domain.Location;
+import com.baeldung.boot.domain.Store;
+
+@RunWith(SpringRunner.class)
+@DataJpaTest(properties="spring.datasource.data=classpath:import_entities.sql")
+public class JpaRepositoriesIntegrationTest {
+    @Autowired
+    private LocationRepository locationRepository;
+    @Autowired
+    private StoreRepository storeRepository;
+    @Autowired
+    private ItemTypeRepository compositeRepository;
+    @Autowired
+    private ReadOnlyLocationRepository readOnlyRepository;
+
+    @Test
+    public void whenSaveLocation_ThenGetSameLocation() {
+        Location location = new Location();
+        location.setId(100L);
+        location.setCountry("Country H");
+        location.setCity("City Hundred");
+        location = locationRepository.saveAndFlush(location);
+
+        Location otherLocation = locationRepository.getOne(location.getId());
+        assertEquals("Country H", otherLocation.getCountry());
+        assertEquals("City Hundred", otherLocation.getCity());
+
+        locationRepository.delete(otherLocation);
+    }
+
+    @Test
+    public void givenLocationId_whenFindStores_thenGetStores() {
+        List<Store> stores = storeRepository.findStoreByLocationId(1L);
+        assertEquals(1, stores.size());
+    }
+
+    @Test
+    public void givenItemTypeId_whenDeleted_ThenItemTypeDeleted() {
+        Optional<ItemType> itemType = compositeRepository.findById(1L);
+        assertTrue(itemType.isPresent());
+        compositeRepository.deleteCustom(itemType.get());
+        itemType = compositeRepository.findById(1L);
+        assertFalse(itemType.isPresent());
+    }
+
+    @Test
+    public void givenItemId_whenUsingCustomRepo_ThenDeleteAppropriateEntity() {
+        Item item = compositeRepository.findItemById(1L);
+        assertNotNull(item);
+        compositeRepository.deleteCustom(item);
+        item = compositeRepository.findItemById(1L);
+        assertNull(item);
+    }
+
+    @Test
+    public void givenItemAndItemType_WhenAmbiguousDeleteCalled_ThenItemTypeDeletedAndNotItem() {
+        Optional<ItemType> itemType = compositeRepository.findById(1L);
+        assertTrue(itemType.isPresent());
+        Item item = compositeRepository.findItemById(2L);
+        assertNotNull(item);
+
+        compositeRepository.findThenDelete(1L);
+        Optional<ItemType> sameItemType = compositeRepository.findById(1L);
+        assertFalse(sameItemType.isPresent());
+        Item sameItem = compositeRepository.findItemById(2L);
+        assertNotNull(sameItem);
+    }
+
+    @Test
+    public void whenCreatingReadOnlyRepo_thenHaveOnlyReadOnlyOperationsAvailable() {
+        Optional<Location> location = readOnlyRepository.findById(1L);
+        assertNotNull(location);
+    }
+}

persistence-modules/spring-data-jpa/src/test/java/com/baeldung/boot/daos/UserRepositoryCommon.java

@@ -0,0 +1,545 @@
+package com.baeldung.boot.daos;
+
+import org.junit.After;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.jpa.domain.JpaSort;
+import org.springframework.data.mapping.PropertyReferenceException;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.baeldung.boot.daos.user.UserRepository;
+import com.baeldung.boot.domain.User;
+
+import javax.persistence.EntityManager;
+import javax.persistence.Query;
+import java.time.LocalDate;
+import java.util.*;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.*;
+
+public class UserRepositoryCommon {
+
+    final String USER_EMAIL = "email@example.com";
+    final String USER_EMAIL2 = "email2@example.com";
+    final String USER_EMAIL3 = "email3@example.com";
+    final String USER_EMAIL4 = "email4@example.com";
+    final Integer INACTIVE_STATUS = 0;
+    final Integer ACTIVE_STATUS = 1;
+    final String USER_EMAIL5 = "email5@example.com";
+    final String USER_EMAIL6 = "email6@example.com";
+    final String USER_NAME_ADAM = "Adam";
+    final String USER_NAME_PETER = "Peter";
+
+    @Autowired
+    protected UserRepository userRepository;
+    @Autowired
+    private EntityManager entityManager;
+
+    @Test
+    @Transactional
+    public void givenUsersWithSameNameInDB_WhenFindAllByName_ThenReturnStreamOfUsers() {
+        User user1 = new User();
+        user1.setName(USER_NAME_ADAM);
+        user1.setEmail(USER_EMAIL);
+        userRepository.save(user1);
+
+        User user2 = new User();
+        user2.setName(USER_NAME_ADAM);
+        user2.setEmail(USER_EMAIL2);
+        userRepository.save(user2);
+
+        User user3 = new User();
+        user3.setName(USER_NAME_ADAM);
+        user3.setEmail(USER_EMAIL3);
+        userRepository.save(user3);
+
+        User user4 = new User();
+        user4.setName("SAMPLE");
+        user4.setEmail(USER_EMAIL4);
+        userRepository.save(user4);
+
+        try (Stream<User> foundUsersStream = userRepository.findAllByName(USER_NAME_ADAM)) {
+            assertThat(foundUsersStream.count()).isEqualTo(3l);
+        }
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindAllWithQueryAnnotation_ThenReturnCollectionWithActiveUsers() {
+        User user1 = new User();
+        user1.setName(USER_NAME_ADAM);
+        user1.setEmail(USER_EMAIL);
+        user1.setStatus(ACTIVE_STATUS);
+        userRepository.save(user1);
+
+        User user2 = new User();
+        user2.setName(USER_NAME_ADAM);
+        user2.setEmail(USER_EMAIL2);
+        user2.setStatus(ACTIVE_STATUS);
+        userRepository.save(user2);
+
+        User user3 = new User();
+        user3.setName(USER_NAME_ADAM);
+        user3.setEmail(USER_EMAIL3);
+        user3.setStatus(INACTIVE_STATUS);
+        userRepository.save(user3);
+
+        Collection<User> allActiveUsers = userRepository.findAllActiveUsers();
+
+        assertThat(allActiveUsers.size()).isEqualTo(2);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindAllWithQueryAnnotationNative_ThenReturnCollectionWithActiveUsers() {
+        User user1 = new User();
+        user1.setName(USER_NAME_ADAM);
+        user1.setEmail(USER_EMAIL);
+        user1.setStatus(ACTIVE_STATUS);
+        userRepository.save(user1);
+
+        User user2 = new User();
+        user2.setName(USER_NAME_ADAM);
+        user2.setEmail(USER_EMAIL2);
+        user2.setStatus(ACTIVE_STATUS);
+        userRepository.save(user2);
+
+        User user3 = new User();
+        user3.setName(USER_NAME_ADAM);
+        user3.setEmail(USER_EMAIL3);
+        user3.setStatus(INACTIVE_STATUS);
+        userRepository.save(user3);
+
+        Collection<User> allActiveUsers = userRepository.findAllActiveUsersNative();
+
+        assertThat(allActiveUsers.size()).isEqualTo(2);
+    }
+
+    @Test
+    public void givenUserInDB_WhenFindUserByStatusWithQueryAnnotation_ThenReturnActiveUser() {
+        User user = new User();
+        user.setName(USER_NAME_ADAM);
+        user.setEmail(USER_EMAIL);
+        user.setStatus(ACTIVE_STATUS);
+        userRepository.save(user);
+
+        User userByStatus = userRepository.findUserByStatus(ACTIVE_STATUS);
+
+        assertThat(userByStatus.getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUserInDB_WhenFindUserByStatusWithQueryAnnotationNative_ThenReturnActiveUser() {
+        User user = new User();
+        user.setName(USER_NAME_ADAM);
+        user.setEmail(USER_EMAIL);
+        user.setStatus(ACTIVE_STATUS);
+        userRepository.save(user);
+
+        User userByStatus = userRepository.findUserByStatusNative(ACTIVE_STATUS);
+
+        assertThat(userByStatus.getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindUserByStatusAndNameWithQueryAnnotationIndexedParams_ThenReturnOneUser() {
+        User user = new User();
+        user.setName(USER_NAME_ADAM);
+        user.setEmail(USER_EMAIL);
+        user.setStatus(ACTIVE_STATUS);
+        userRepository.save(user);
+
+        User user2 = new User();
+        user2.setName(USER_NAME_PETER);
+        user2.setEmail(USER_EMAIL2);
+        user2.setStatus(ACTIVE_STATUS);
+        userRepository.save(user2);
+
+        User userByStatus = userRepository.findUserByStatusAndName(ACTIVE_STATUS, USER_NAME_ADAM);
+
+        assertThat(userByStatus.getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindUserByStatusAndNameWithQueryAnnotationNamedParams_ThenReturnOneUser() {
+        User user = new User();
+        user.setName(USER_NAME_ADAM);
+        user.setEmail(USER_EMAIL);
+        user.setStatus(ACTIVE_STATUS);
+        userRepository.save(user);
+
+        User user2 = new User();
+        user2.setName(USER_NAME_PETER);
+        user2.setEmail(USER_EMAIL2);
+        user2.setStatus(ACTIVE_STATUS);
+        userRepository.save(user2);
+
+        User userByStatus = userRepository.findUserByStatusAndNameNamedParams(ACTIVE_STATUS, USER_NAME_ADAM);
+
+        assertThat(userByStatus.getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindUserByStatusAndNameWithQueryAnnotationNativeNamedParams_ThenReturnOneUser() {
+        User user = new User();
+        user.setName(USER_NAME_ADAM);
+        user.setEmail(USER_EMAIL);
+        user.setStatus(ACTIVE_STATUS);
+        userRepository.save(user);
+
+        User user2 = new User();
+        user2.setName(USER_NAME_PETER);
+        user2.setEmail(USER_EMAIL2);
+        user2.setStatus(ACTIVE_STATUS);
+        userRepository.save(user2);
+
+        User userByStatus = userRepository.findUserByStatusAndNameNamedParamsNative(ACTIVE_STATUS, USER_NAME_ADAM);
+
+        assertThat(userByStatus.getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindUserByStatusAndNameWithQueryAnnotationNamedParamsCustomNames_ThenReturnOneUser() {
+        User user = new User();
+        user.setName(USER_NAME_ADAM);
+        user.setEmail(USER_EMAIL);
+        user.setStatus(ACTIVE_STATUS);
+        userRepository.save(user);
+
+        User user2 = new User();
+        user2.setName(USER_NAME_PETER);
+        user2.setEmail(USER_EMAIL2);
+        user2.setStatus(ACTIVE_STATUS);
+        userRepository.save(user2);
+
+        User userByStatus = userRepository.findUserByUserStatusAndUserName(ACTIVE_STATUS, USER_NAME_ADAM);
+
+        assertThat(userByStatus.getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindUserByNameLikeWithQueryAnnotationIndexedParams_ThenReturnUser() {
+        User user = new User();
+        user.setName(USER_NAME_ADAM);
+        user.setEmail(USER_EMAIL);
+        user.setStatus(ACTIVE_STATUS);
+        userRepository.save(user);
+
+        User userByStatus = userRepository.findUserByNameLike("Ad");
+
+        assertThat(userByStatus.getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindUserByNameLikeWithQueryAnnotationNamedParams_ThenReturnUser() {
+        User user = new User();
+        user.setName(USER_NAME_ADAM);
+        user.setEmail(USER_EMAIL);
+        user.setStatus(ACTIVE_STATUS);
+        userRepository.save(user);
+
+        User userByStatus = userRepository.findUserByNameLikeNamedParam("Ad");
+
+        assertThat(userByStatus.getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindUserByNameLikeWithQueryAnnotationNative_ThenReturnUser() {
+        User user = new User();
+        user.setName(USER_NAME_ADAM);
+        user.setEmail(USER_EMAIL);
+        user.setStatus(ACTIVE_STATUS);
+        userRepository.save(user);
+
+        User userByStatus = userRepository.findUserByNameLikeNative("Ad");
+
+        assertThat(userByStatus.getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindAllWithSortByName_ThenReturnUsersSorted() {
+        userRepository.save(new User(USER_NAME_ADAM, LocalDate.now(), USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User(USER_NAME_PETER, LocalDate.now(), USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL3, INACTIVE_STATUS));
+
+        List<User> usersSortByName = userRepository.findAll(new Sort(Sort.Direction.ASC, "name"));
+
+        assertThat(usersSortByName.get(0)
+          .getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test(expected = PropertyReferenceException.class)
+    public void givenUsersInDB_WhenFindAllSortWithFunction_ThenThrowException() {
+        userRepository.save(new User(USER_NAME_ADAM, LocalDate.now(), USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User(USER_NAME_PETER, LocalDate.now(), USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL3, INACTIVE_STATUS));
+
+        userRepository.findAll(new Sort(Sort.Direction.ASC, "name"));
+
+        List<User> usersSortByNameLength = userRepository.findAll(Sort.by("LENGTH(name)"));
+
+        assertThat(usersSortByNameLength.get(0)
+          .getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindAllSortWithFunctionQueryAnnotationJPQL_ThenReturnUsersSorted() {
+        userRepository.save(new User(USER_NAME_ADAM, LocalDate.now(), USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User(USER_NAME_PETER, LocalDate.now(), USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL3, INACTIVE_STATUS));
+
+        userRepository.findAllUsers(Sort.by("name"));
+
+        List<User> usersSortByNameLength = userRepository.findAllUsers(JpaSort.unsafe("LENGTH(name)"));
+
+        assertThat(usersSortByNameLength.get(0)
+          .getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindAllWithPageRequestQueryAnnotationJPQL_ThenReturnPageOfUsers() {
+        userRepository.save(new User(USER_NAME_ADAM, LocalDate.now(), USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User(USER_NAME_PETER, LocalDate.now(), USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL3, INACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE1", LocalDate.now(), USER_EMAIL4, INACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE2", LocalDate.now(), USER_EMAIL5, INACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE3", LocalDate.now(), USER_EMAIL6, INACTIVE_STATUS));
+
+        Page<User> usersPage = userRepository.findAllUsersWithPagination(PageRequest.of(1, 3));
+
+        assertThat(usersPage.getContent()
+          .get(0)
+          .getName()).isEqualTo("SAMPLE1");
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindAllWithPageRequestQueryAnnotationNative_ThenReturnPageOfUsers() {
+        userRepository.save(new User(USER_NAME_ADAM, LocalDate.now(), USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User(USER_NAME_PETER, LocalDate.now(), USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL3, INACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE1", LocalDate.now(), USER_EMAIL4, INACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE2", LocalDate.now(), USER_EMAIL5, INACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE3", LocalDate.now(), USER_EMAIL6, INACTIVE_STATUS));
+
+        Page<User> usersSortByNameLength = userRepository.findAllUsersWithPaginationNative(PageRequest.of(1, 3));
+
+        assertThat(usersSortByNameLength.getContent()
+          .get(0)
+          .getName()).isEqualTo(USER_NAME_PETER);
+    }
+
+    @Test
+    @Transactional
+    public void givenUsersInDB_WhenUpdateStatusForNameModifyingQueryAnnotationJPQL_ThenModifyMatchingUsers() {
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE1", LocalDate.now(), USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL3, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE3", LocalDate.now(), USER_EMAIL4, ACTIVE_STATUS));
+
+        int updatedUsersSize = userRepository.updateUserSetStatusForName(INACTIVE_STATUS, "SAMPLE");
+
+        assertThat(updatedUsersSize).isEqualTo(2);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindByEmailsWithDynamicQuery_ThenReturnCollection() {
+
+        User user1 = new User();
+        user1.setEmail(USER_EMAIL);
+        userRepository.save(user1);
+
+        User user2 = new User();
+        user2.setEmail(USER_EMAIL2);
+        userRepository.save(user2);
+
+        User user3 = new User();
+        user3.setEmail(USER_EMAIL3);
+        userRepository.save(user3);
+
+        Set<String> emails = new HashSet<>();
+        emails.add(USER_EMAIL2);
+        emails.add(USER_EMAIL3);
+
+        Collection<User> usersWithEmails = userRepository.findUserByEmails(emails);
+
+        assertThat(usersWithEmails.size()).isEqualTo(2);
+    }
+
+    @Test
+    public void givenUsersInDBWhenFindByNameListReturnCollection() {
+
+        User user1 = new User();
+        user1.setName(USER_NAME_ADAM);
+        user1.setEmail(USER_EMAIL);
+        userRepository.save(user1);
+
+        User user2 = new User();
+        user2.setName(USER_NAME_PETER);
+        user2.setEmail(USER_EMAIL2);
+        userRepository.save(user2);
+
+        List<String> names = Arrays.asList(USER_NAME_ADAM, USER_NAME_PETER);
+
+        List<User> usersWithNames = userRepository.findUserByNameList(names);
+
+        assertThat(usersWithNames.size()).isEqualTo(2);
+    }
+
+
+    @Test
+    @Transactional
+    public void whenInsertedWithQuery_ThenUserIsPersisted() {
+        userRepository.insertUser(USER_NAME_ADAM, 1, USER_EMAIL, ACTIVE_STATUS, true);
+        userRepository.insertUser(USER_NAME_PETER, 1, USER_EMAIL2, ACTIVE_STATUS, true);
+
+        User userAdam = userRepository.findUserByNameLike(USER_NAME_ADAM);
+        User userPeter = userRepository.findUserByNameLike(USER_NAME_PETER);
+
+        assertThat(userAdam).isNotNull();
+        assertThat(userAdam.getEmail()).isEqualTo(USER_EMAIL);
+        assertThat(userPeter).isNotNull();
+        assertThat(userPeter.getEmail()).isEqualTo(USER_EMAIL2);
+    }
+
+
+    @Test
+    @Transactional
+    public void givenTwoUsers_whenFindByNameUsr01_ThenUserUsr01() {
+        User usr01 = new User("usr01", LocalDate.now(), "usr01@baeldung.com", 1);
+        User usr02 = new User("usr02", LocalDate.now(), "usr02@baeldung.com", 1);
+
+        userRepository.save(usr01);
+        userRepository.save(usr02);
+
+        try (Stream<User> users = userRepository.findAllByName("usr01")) {
+            assertTrue(users.allMatch(usr -> usr.equals(usr01)));
+        }
+    }
+
+    @Test
+    @Transactional
+    public void givenTwoUsers_whenFindByNameUsr00_ThenNoUsers() {
+        User usr01 = new User("usr01", LocalDate.now(), "usr01@baeldung.com", 1);
+        User usr02 = new User("usr02", LocalDate.now(), "usr02@baeldung.com", 1);
+
+        userRepository.save(usr01);
+        userRepository.save(usr02);
+
+        try (Stream<User> users = userRepository.findAllByName("usr00")) {
+            assertEquals(0, users.count());
+        }
+    }
+
+    @Test
+    public void givenTwoUsers_whenFindUsersWithGmailAddress_ThenUserUsr02() {
+        User usr01 = new User("usr01", LocalDate.now(), "usr01@baeldung.com", 1);
+        User usr02 = new User("usr02", LocalDate.now(), "usr02@gmail.com", 1);
+
+        userRepository.save(usr01);
+        userRepository.save(usr02);
+
+        List<User> users = userRepository.findUsersWithGmailAddress();
+        assertEquals(1, users.size());
+        assertEquals(usr02, users.get(0));
+    }
+
+    @Test
+    @Transactional
+    public void givenTwoUsers_whenDeleteAllByCreationDateAfter_ThenOneUserRemains() {
+        User usr01 = new User("usr01", LocalDate.of(2018, 1, 1), "usr01@baeldung.com", 1);
+        User usr02 = new User("usr02", LocalDate.of(2018, 6, 1), "usr02@baeldung.com", 1);
+
+        userRepository.save(usr01);
+        userRepository.save(usr02);
+
+        userRepository.deleteAllByCreationDateAfter(LocalDate.of(2018, 5, 1));
+
+        List<User> users = userRepository.findAll();
+
+        assertEquals(1, users.size());
+        assertEquals(usr01, users.get(0));
+    }
+
+    @Test
+    public void givenTwoUsers_whenFindAllUsersByPredicates_ThenUserUsr01() {
+        User usr01 = new User("usr01", LocalDate.of(2018, 1, 1), "usr01@baeldung.com", 1);
+        User usr02 = new User("usr02", LocalDate.of(2018, 6, 1), "usr02@baeldung.org", 1);
+
+        userRepository.save(usr01);
+        userRepository.save(usr02);
+
+        List<Predicate<User>> predicates = new ArrayList<>();
+        predicates.add(usr -> usr.getCreationDate().isAfter(LocalDate.of(2017, 12, 31)));
+        predicates.add(usr -> usr.getEmail().endsWith(".com"));
+
+        List<User> users = userRepository.findAllUsersByPredicates(predicates);
+
+        assertEquals(1, users.size());
+        assertEquals(usr01, users.get(0));
+    }
+
+    @Test
+    @Transactional
+    public void givenTwoUsers_whenDeactivateUsersNotLoggedInSince_ThenUserUsr02Deactivated() {
+        User usr01 = new User("usr01", LocalDate.of(2018, 1, 1), "usr01@baeldung.com", 1);
+        usr01.setLastLoginDate(LocalDate.now());
+        User usr02 = new User("usr02", LocalDate.of(2018, 6, 1), "usr02@baeldung.org", 1);
+        usr02.setLastLoginDate(LocalDate.of(2018, 7, 20));
+
+        userRepository.save(usr01);
+        userRepository.save(usr02);
+
+        userRepository.deactivateUsersNotLoggedInSince(LocalDate.of(2018, 8, 1));
+
+        List<User> users = userRepository.findAllUsers(Sort.by(Sort.Order.asc("name")));
+        assertTrue(users.get(0).isActive());
+        assertFalse(users.get(1).isActive());
+    }
+
+    @Test
+    @Transactional
+    public void givenTwoUsers_whenDeleteDeactivatedUsers_ThenUserUsr02Deleted() {
+        User usr01 = new User("usr01", LocalDate.of(2018, 1, 1), "usr01@baeldung.com", 1);
+        usr01.setLastLoginDate(LocalDate.now());
+        User usr02 = new User("usr02", LocalDate.of(2018, 6, 1), "usr02@baeldung.com", 0);
+        usr02.setLastLoginDate(LocalDate.of(2018, 7, 20));
+        usr02.setActive(false);
+
+        userRepository.save(usr01);
+        userRepository.save(usr02);
+
+        int deletedUsersCount = userRepository.deleteDeactivatedUsers();
+
+        List<User> users = userRepository.findAll();
+        assertEquals(1, users.size());
+        assertEquals(usr01, users.get(0));
+        assertEquals(1, deletedUsersCount);
+    }
+
+    @Test
+    @Transactional
+    public void givenTwoUsers_whenAddDeletedColumn_ThenUsersHaveDeletedColumn() {
+        User usr01 = new User("usr01", LocalDate.of(2018, 1, 1), "usr01@baeldung.com", 1);
+        usr01.setLastLoginDate(LocalDate.now());
+        User usr02 = new User("usr02", LocalDate.of(2018, 6, 1), "usr02@baeldung.org", 1);
+        usr02.setLastLoginDate(LocalDate.of(2018, 7, 20));
+        usr02.setActive(false);
+
+        userRepository.save(usr01);
+        userRepository.save(usr02);
+
+        userRepository.addDeletedColumn();
+
+        Query nativeQuery = entityManager.createNativeQuery("select deleted from USERS where NAME = 'usr01'");
+        assertEquals(0, nativeQuery.getResultList().get(0));
+    }
+
+    @After
+    public void cleanUp() {
+        userRepository.deleteAll();
+    }
+}

persistence-modules/spring-data-jpa/src/test/java/com/baeldung/boot/daos/UserRepositoryIntegrationTest.java

@@ -0,0 +1,37 @@
+package com.baeldung.boot.daos;
+
+import com.baeldung.boot.Application;
+import com.baeldung.boot.domain.User;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDate;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Created by adam.
+ */
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = Application.class)
+@DirtiesContext
+public class UserRepositoryIntegrationTest extends UserRepositoryCommon {
+
+    @Test
+    @Transactional
+    public void givenUsersInDBWhenUpdateStatusForNameModifyingQueryAnnotationNativeThenModifyMatchingUsers() {
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE1", LocalDate.now(), USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL3, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE3", LocalDate.now(), USER_EMAIL4, ACTIVE_STATUS));
+        userRepository.flush();
+
+        int updatedUsersSize = userRepository.updateUserSetStatusForNameNative(INACTIVE_STATUS, "SAMPLE");
+
+        assertThat(updatedUsersSize).isEqualTo(2);
+    }
+}

persistence-modules/spring-data-jpa/src/test/java/com/baeldung/boot/daos/UserRepositoryTCAutoLiveTest.java

@@ -0,0 +1,43 @@
+package com.baeldung.boot.daos;
+
+import com.baeldung.boot.Application;
+import com.baeldung.boot.domain.User;
+import com.baeldung.util.BaeldungPostgresqlContainer;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.transaction.annotation.Transactional;
+import org.testcontainers.containers.PostgreSQLContainer;
+
+import java.time.LocalDate;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Created by adam.
+ */
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = Application.class)
+@ActiveProfiles({"tc", "tc-auto"})
+public class UserRepositoryTCAutoLiveTest extends UserRepositoryCommon {
+
+    @ClassRule
+    public static PostgreSQLContainer<BaeldungPostgresqlContainer> postgreSQLContainer = BaeldungPostgresqlContainer.getInstance();
+
+    @Test
+    @Transactional
+    public void givenUsersInDB_WhenUpdateStatusForNameModifyingQueryAnnotationNativePostgres_ThenModifyMatchingUsers() {
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE1", LocalDate.now(), USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL3, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE3", LocalDate.now(), USER_EMAIL4, ACTIVE_STATUS));
+        userRepository.flush();
+
+        int updatedUsersSize = userRepository.updateUserSetStatusForNameNativePostgres(INACTIVE_STATUS, "SAMPLE");
+
+        assertThat(updatedUsersSize).isEqualTo(2);
+    }
+}

persistence-modules/spring-data-jpa/src/test/java/com/baeldung/boot/daos/UserRepositoryTCLiveTest.java

@@ -0,0 +1,58 @@
+package com.baeldung.boot.daos;
+
+import com.baeldung.boot.Application;
+import com.baeldung.boot.domain.User;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.util.TestPropertyValues;
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.transaction.annotation.Transactional;
+import org.testcontainers.containers.PostgreSQLContainer;
+
+import java.time.LocalDate;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = Application.class)
+@ActiveProfiles("tc")
+@ContextConfiguration(initializers = {UserRepositoryTCLiveTest.Initializer.class})
+public class UserRepositoryTCLiveTest extends UserRepositoryCommon {
+
+    @ClassRule
+    public static PostgreSQLContainer postgreSQLContainer = new PostgreSQLContainer("postgres:11.1")
+      .withDatabaseName("integration-tests-db")
+      .withUsername("sa")
+      .withPassword("sa");
+
+    @Test
+    @Transactional
+    public void givenUsersInDB_WhenUpdateStatusForNameModifyingQueryAnnotationNative_ThenModifyMatchingUsers() {
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE1", LocalDate.now(), USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", LocalDate.now(), USER_EMAIL3, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE3", LocalDate.now(), USER_EMAIL4, ACTIVE_STATUS));
+        userRepository.flush();
+
+        int updatedUsersSize = userRepository.updateUserSetStatusForNameNativePostgres(INACTIVE_STATUS, "SAMPLE");
+
+        assertThat(updatedUsersSize).isEqualTo(2);
+    }
+
+    static class Initializer
+      implements ApplicationContextInitializer<ConfigurableApplicationContext> {
+        public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
+            TestPropertyValues.of(
+              "spring.datasource.url=" + postgreSQLContainer.getJdbcUrl(),
+              "spring.datasource.username=" + postgreSQLContainer.getUsername(),
+              "spring.datasource.password=" + postgreSQLContainer.getPassword()
+            ).applyTo(configurableApplicationContext.getEnvironment());
+        }
+    }
+}

persistence-modules/spring-data-jpa/src/test/java/com/baeldung/boot/ddd/event/Aggregate2EventsIntegrationTest.java

@@ -0,0 +1,72 @@
+/**
+ *
+ */
+package com.baeldung.boot.ddd.event;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
+
+import com.baeldung.boot.ddd.event.Aggregate2;
+import com.baeldung.boot.ddd.event.Aggregate2Repository;
+import com.baeldung.boot.ddd.event.DomainEvent;
+
+@SpringJUnitConfig
+@SpringBootTest
+class Aggregate2EventsIntegrationTest {
+    @MockBean
+    private TestEventHandler eventHandler;
+    @Autowired
+    private Aggregate2Repository repository;
+
+    // @formatter:off
+    @DisplayName("given aggregate with @AfterDomainEventPublication,"
+        + " when do domain operation and save twice,"
+        + " then an event is published only for the first time")
+    // @formatter:on
+    @Test
+    void afterDomainEvents() {
+        // given
+        Aggregate2 aggregate = new Aggregate2();
+
+        // when
+        aggregate.domainOperation();
+        repository.save(aggregate);
+        repository.save(aggregate);
+
+        // then
+        verify(eventHandler, times(1)).handleEvent(any(DomainEvent.class));
+    }
+
+    @BeforeEach
+    void beforeEach() {
+        repository.deleteAll();
+    }
+
+    // @formatter:off
+    @DisplayName("given aggregate with @DomainEvents,"
+        + " when do domain operation and save,"
+        + " then an event is published")
+    // @formatter:on
+    @Test
+    void domainEvents() {
+        // given
+        Aggregate2 aggregate = new Aggregate2();
+
+        // when
+        aggregate.domainOperation();
+        repository.save(aggregate);
+
+        // then
+        verify(eventHandler, times(1)).handleEvent(any(DomainEvent.class));
+    }
+
+}

persistence-modules/spring-data-jpa/src/test/java/com/baeldung/boot/ddd/event/Aggregate3EventsIntegrationTest.java

@@ -0,0 +1,67 @@
+/**
+ *
+ */
+package com.baeldung.boot.ddd.event;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
+
+import com.baeldung.boot.ddd.event.Aggregate3;
+import com.baeldung.boot.ddd.event.Aggregate3Repository;
+import com.baeldung.boot.ddd.event.DomainEvent;
+
+@SpringJUnitConfig
+@SpringBootTest
+class Aggregate3EventsIntegrationTest {
+
+    @MockBean
+    private TestEventHandler eventHandler;
+    @Autowired
+    private Aggregate3Repository repository;
+
+    // @formatter:off
+    @DisplayName("given aggregate extending AbstractAggregateRoot,"
+        + " when do domain operation and save twice,"
+        + " then an event is published only for the first time")
+    // @formatter:on
+    @Test
+    void afterDomainEvents() {
+        // given
+        Aggregate3 aggregate = new Aggregate3();
+
+        // when
+        aggregate.domainOperation();
+        repository.save(aggregate);
+        repository.save(aggregate);
+
+        // then
+        verify(eventHandler, times(1)).handleEvent(any(DomainEvent.class));
+    }
+
+    // @formatter:off
+    @DisplayName("given aggregate extending AbstractAggregateRoot,"
+        + " when do domain operation and save,"
+        + " then an event is published")
+    // @formatter:on
+    @Test
+    void domainEvents() {
+        // given
+        Aggregate3 aggregate = new Aggregate3();
+
+        // when
+        aggregate.domainOperation();
+        repository.save(aggregate);
+
+        // then
+        verify(eventHandler, times(1)).handleEvent(any(DomainEvent.class));
+    }
+
+}

persistence-modules/spring-data-jpa/src/test/java/com/baeldung/boot/ddd/event/AggregateEventsIntegrationTest.java

@@ -0,0 +1,87 @@
+package com.baeldung.boot.ddd.event;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.context.TestConfiguration;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.context.annotation.Bean;
+import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
+
+import com.baeldung.boot.ddd.event.Aggregate;
+import com.baeldung.boot.ddd.event.AggregateRepository;
+import com.baeldung.boot.ddd.event.DomainEvent;
+import com.baeldung.boot.ddd.event.DomainService;
+
+@SpringJUnitConfig
+@SpringBootTest
+class AggregateEventsIntegrationTest {
+
+    @Autowired
+    private DomainService domainService;
+
+    @MockBean
+    private TestEventHandler eventHandler;
+    @Autowired
+    private ApplicationEventPublisher eventPublisher;
+    @Autowired
+    private AggregateRepository repository;
+
+    // @formatter:off
+    @DisplayName("given existing aggregate,"
+        + " when do domain operation directly on aggregate,"
+        + " then domain event is NOT published")
+    // @formatter:on
+    @Test
+    void aggregateEventsTest() {
+        Aggregate existingDomainEntity = new Aggregate(0, eventPublisher);
+        repository.save(existingDomainEntity);
+
+        // when
+        repository.findById(existingDomainEntity.getId())
+            .get()
+            .domainOperation();
+
+        // then
+        verifyZeroInteractions(eventHandler);
+    }
+
+    @BeforeEach
+    void beforeEach() {
+        repository.deleteAll();
+    }
+
+    // @formatter:off
+    @DisplayName("given existing aggregate,"
+        + " when do domain operation on service,"
+        + " then domain event is published")
+    // @formatter:on
+    @Test
+    void serviceEventsTest() {
+        Aggregate existingDomainEntity = new Aggregate(1, eventPublisher);
+        repository.save(existingDomainEntity);
+
+        // when
+        domainService.serviceDomainOperation(existingDomainEntity.getId());
+
+        // then
+        verify(eventHandler, times(1)).handleEvent(any(DomainEvent.class));
+    }
+
+    @TestConfiguration
+    public static class TestConfig {
+        @Bean
+        public DomainService domainService(AggregateRepository repository, ApplicationEventPublisher eventPublisher) {
+            return new DomainService(repository, eventPublisher);
+        }
+    }
+
+}

persistence-modules/spring-data-jpa/src/test/java/com/baeldung/boot/ddd/event/TestEventHandler.java

@@ -0,0 +1,14 @@
+/**
+ *
+ */
+package com.baeldung.boot.ddd.event;
+
+import org.springframework.transaction.event.TransactionalEventListener;
+
+import com.baeldung.boot.ddd.event.DomainEvent;
+
+interface TestEventHandler {
+    @TransactionalEventListener
+    void handleEvent(DomainEvent event);
+
+}

persistence-modules/spring-data-jpa/src/test/java/com/baeldung/boot/services/AbstractServicePersistenceIntegrationTest.java

@@ -0,0 +1,252 @@
+package com.baeldung.boot.services;
+
+import com.baeldung.boot.domain.Foo;
+import com.baeldung.boot.services.IOperations;
+import com.baeldung.util.IDUtil;
+import org.hamcrest.Matchers;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.springframework.dao.DataAccessException;
+
+import java.io.Serializable;
+import java.util.List;
+
+import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
+import static org.hamcrest.Matchers.hasItem;
+import static org.hamcrest.Matchers.not;
+import static org.junit.Assert.*;
+
+public abstract class AbstractServicePersistenceIntegrationTest<T extends Serializable> {
+
+    // tests
+
+    // find - one
+
+    @Test
+    /**/public final void givenResourceDoesNotExist_whenResourceIsRetrieved_thenNoResourceIsReceived() {
+        // When
+        final Foo createdResource = getApi().findOne(IDUtil.randomPositiveLong());
+
+        // Then
+        assertNull(createdResource);
+    }
+
+    @Test
+    public void givenResourceExists_whenResourceIsRetrieved_thenNoExceptions() {
+        final Foo existingResource = persistNewEntity();
+        getApi().findOne(existingResource.getId());
+    }
+
+    @Test
+    public void givenResourceDoesNotExist_whenResourceIsRetrieved_thenNoExceptions() {
+        getApi().findOne(IDUtil.randomPositiveLong());
+    }
+
+    @Test
+    public void givenResourceExists_whenResourceIsRetrieved_thenTheResultIsNotNull() {
+        final Foo existingResource = persistNewEntity();
+        final Foo retrievedResource = getApi().findOne(existingResource.getId());
+        assertNotNull(retrievedResource);
+    }
+
+    @Test
+    public void givenResourceExists_whenResourceIsRetrieved_thenResourceIsRetrievedCorrectly() {
+        final Foo existingResource = persistNewEntity();
+        final Foo retrievedResource = getApi().findOne(existingResource.getId());
+        assertEquals(existingResource, retrievedResource);
+    }
+
+    // find - one - by name
+
+    // find - all
+
+    @Test
+    /**/public void whenAllResourcesAreRetrieved_thenNoExceptions() {
+        getApi().findAll();
+    }
+
+    @Test
+    /**/public void whenAllResourcesAreRetrieved_thenTheResultIsNotNull() {
+        final List<Foo> resources = getApi().findAll();
+
+        assertNotNull(resources);
+    }
+
+    @Test
+    /**/public void givenAtLeastOneResourceExists_whenAllResourcesAreRetrieved_thenRetrievedResourcesAreNotEmpty() {
+        persistNewEntity();
+
+        // When
+        final List<Foo> allResources = getApi().findAll();
+
+        // Then
+        assertThat(allResources, not(Matchers.<Foo> empty()));
+    }
+
+    @Test
+    /**/public void givenAnResourceExists_whenAllResourcesAreRetrieved_thenTheExistingResourceIsIndeedAmongThem() {
+        final Foo existingResource = persistNewEntity();
+
+        final List<Foo> resources = getApi().findAll();
+
+        assertThat(resources, hasItem(existingResource));
+    }
+
+    @Test
+    /**/public void whenAllResourcesAreRetrieved_thenResourcesHaveIds() {
+        persistNewEntity();
+
+        // When
+        final List<Foo> allResources = getApi().findAll();
+
+        // Then
+        for (final Foo resource : allResources) {
+            assertNotNull(resource.getId());
+        }
+    }
+
+    // create
+
+    @Test(expected = RuntimeException.class)
+    /**/public void whenNullResourceIsCreated_thenException() {
+        getApi().create(null);
+    }
+
+    @Test
+    /**/public void whenResourceIsCreated_thenNoExceptions() {
+        persistNewEntity();
+    }
+
+    @Test
+    /**/public void whenResourceIsCreated_thenResourceIsRetrievable() {
+        final Foo existingResource = persistNewEntity();
+
+        assertNotNull(getApi().findOne(existingResource.getId()));
+    }
+
+    @Test
+    /**/public void whenResourceIsCreated_thenSavedResourceIsEqualToOriginalResource() {
+        final Foo originalResource = createNewEntity();
+        final Foo savedResource = getApi().create(originalResource);
+
+        assertEquals(originalResource, savedResource);
+    }
+
+    @Test(expected = RuntimeException.class)
+    public void whenResourceWithFailedConstraintsIsCreated_thenException() {
+        final Foo invalidResource = createNewEntity();
+        invalidate(invalidResource);
+
+        getApi().create(invalidResource);
+    }
+
+    /**
+     * -- specific to the persistence engine
+     */
+    @Test(expected = DataAccessException.class)
+    @Ignore("Hibernate simply ignores the id silently and still saved (tracking this)")
+    public void whenResourceWithIdIsCreated_thenDataAccessException() {
+        final Foo resourceWithId = createNewEntity();
+        resourceWithId.setId(IDUtil.randomPositiveLong());
+
+        getApi().create(resourceWithId);
+    }
+
+    // update
+
+    @Test(expected = RuntimeException.class)
+    /**/public void whenNullResourceIsUpdated_thenException() {
+        getApi().update(null);
+    }
+
+    @Test
+    /**/public void givenResourceExists_whenResourceIsUpdated_thenNoExceptions() {
+        // Given
+        final Foo existingResource = persistNewEntity();
+
+        // When
+        getApi().update(existingResource);
+    }
+
+    /**
+     * - can also be the ConstraintViolationException which now occurs on the update operation will not be translated; as a consequence, it will be a TransactionSystemException
+     */
+    @Test(expected = RuntimeException.class)
+    public void whenResourceIsUpdatedWithFailedConstraints_thenException() {
+        final Foo existingResource = persistNewEntity();
+        invalidate(existingResource);
+
+        getApi().update(existingResource);
+    }
+
+    @Test
+    /**/public void givenResourceExists_whenResourceIsUpdated_thenUpdatesArePersisted() {
+        // Given
+        final Foo existingResource = persistNewEntity();
+
+        // When
+        change(existingResource);
+        getApi().update(existingResource);
+
+        final Foo updatedResource = getApi().findOne(existingResource.getId());
+
+        // Then
+        assertEquals(existingResource, updatedResource);
+    }
+
+    // delete
+
+    // @Test(expected = RuntimeException.class)
+    // public void givenResourceDoesNotExists_whenResourceIsDeleted_thenException() {
+    // // When
+    // getApi().delete(IDUtil.randomPositiveLong());
+    // }
+    //
+    // @Test(expected = RuntimeException.class)
+    // public void whenResourceIsDeletedByNegativeId_thenException() {
+    // // When
+    // getApi().delete(IDUtil.randomNegativeLong());
+    // }
+    //
+    // @Test
+    // public void givenResourceExists_whenResourceIsDeleted_thenNoExceptions() {
+    // // Given
+    // final Foo existingResource = persistNewEntity();
+    //
+    // // When
+    // getApi().delete(existingResource.getId());
+    // }
+    //
+    // @Test
+    // /**/public final void givenResourceExists_whenResourceIsDeleted_thenResourceNoLongerExists() {
+    // // Given
+    // final Foo existingResource = persistNewEntity();
+    //
+    // // When
+    // getApi().delete(existingResource.getId());
+    //
+    // // Then
+    // assertNull(getApi().findOne(existingResource.getId()));
+    // }
+
+    // template method
+
+    protected Foo createNewEntity() {
+        return new Foo(randomAlphabetic(6));
+    }
+
+    protected abstract IOperations<Foo> getApi();
+
+    private final void invalidate(final Foo entity) {
+        entity.setName(null);
+    }
+
+    private final void change(final Foo entity) {
+        entity.setName(randomAlphabetic(6));
+    }
+
+    protected Foo persistNewEntity() {
+        return getApi().create(createNewEntity());
+    }
+
+}

persistence-modules/spring-data-jpa/src/test/java/com/baeldung/boot/services/FooServicePersistenceIntegrationTest.java

@@ -0,0 +1,75 @@
+package com.baeldung.boot.services;
+
+import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
+import static org.junit.Assert.assertNotNull;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.dao.InvalidDataAccessApiUsageException;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.boot.Application;
+import com.baeldung.boot.domain.Foo;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes=Application.class)
+public class FooServicePersistenceIntegrationTest extends AbstractServicePersistenceIntegrationTest<Foo> {
+
+    @Autowired
+    private IFooService service;
+
+    // tests
+
+    @Test
+    public final void whenContextIsBootstrapped_thenNoExceptions() {
+        //
+    }
+
+    @Test
+    public final void whenEntityIsCreated_thenNoExceptions() {
+        service.create(new Foo(randomAlphabetic(6)));
+    }
+
+    @Test(expected = DataIntegrityViolationException.class)
+    public final void whenInvalidEntityIsCreated_thenDataException() {
+        service.create(new Foo());
+    }
+
+    @Test(expected = DataIntegrityViolationException.class)
+    public final void whenEntityWithLongNameIsCreated_thenDataException() {
+        service.create(new Foo(randomAlphabetic(2048)));
+    }
+
+    // custom Query method
+
+    @Test
+    public final void givenUsingCustomQuery_whenRetrievingEntity_thenFound() {
+        final String name = randomAlphabetic(6);
+        service.create(new Foo(name));
+
+        final Foo retrievedByName = service.retrieveByName(name);
+        assertNotNull(retrievedByName);
+    }
+
+    // work in progress
+
+    @Test(expected = InvalidDataAccessApiUsageException.class)
+    @Ignore("Right now, persist has saveOrUpdate semantics, so this will no longer fail")
+    public final void whenSameEntityIsCreatedTwice_thenDataException() {
+        final Foo entity = new Foo(randomAlphabetic(8));
+        service.create(entity);
+        service.create(entity);
+    }
+
+    // API
+
+    @Override
+    protected final IOperations<Foo> getApi() {
+        return service;
+    }
+
+}

persistence-modules/spring-data-jpa/src/test/java/com/baeldung/boot/services/SpringDataJPABarAuditIntegrationTest.java

@@ -0,0 +1,75 @@
+package com.baeldung.boot.services;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.security.test.context.support.WithMockUser;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.boot.Application;
+import com.baeldung.boot.domain.Bar;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes=Application.class)
+public class SpringDataJPABarAuditIntegrationTest {
+
+    private static Logger logger = LoggerFactory.getLogger(SpringDataJPABarAuditIntegrationTest.class);
+
+    @BeforeClass
+    public static void setUpBeforeClass() throws Exception {
+        logger.info("setUpBeforeClass()");
+    }
+
+    @AfterClass
+    public static void tearDownAfterClass() throws Exception {
+        logger.info("tearDownAfterClass()");
+    }
+
+    @Autowired
+    @Qualifier("barSpringDataJpaService")
+    private IBarService barService;
+
+    @Autowired
+    private EntityManagerFactory entityManagerFactory;
+
+    private EntityManager em;
+
+    @Before
+    public void setUp() throws Exception {
+        logger.info("setUp()");
+        em = entityManagerFactory.createEntityManager();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        logger.info("tearDown()");
+        em.close();
+    }
+
+    @Test
+    @WithMockUser(username = "tutorialuser")
+    public final void whenBarsModified_thenBarsAudited() {
+        Bar bar = new Bar("BAR1");
+        barService.create(bar);
+        assertEquals(bar.getCreatedDate(), bar.getModifiedDate());
+        assertEquals("tutorialuser", bar.getCreatedBy(), bar.getModifiedBy());
+        bar.setName("BAR2");
+        bar = barService.update(bar);
+        assertTrue(bar.getCreatedDate() < bar.getModifiedDate());
+        assertEquals("tutorialuser", bar.getCreatedBy(), bar.getModifiedBy());
+    }
+}

persistence-modules/spring-data-jpa/src/test/java/com/baeldung/multipledb/JpaMultipleDBIntegrationTest.java

@@ -0,0 +1,96 @@
+package com.baeldung.multipledb;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.Collections;
+import java.util.Optional;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.baeldung.multipledb.dao.product.ProductRepository;
+import com.baeldung.multipledb.dao.user.PossessionRepository;
+import com.baeldung.multipledb.dao.user.UserRepository;
+import com.baeldung.multipledb.model.product.ProductMultipleDB;
+import com.baeldung.multipledb.model.user.PossessionMultipleDB;
+import com.baeldung.multipledb.model.user.UserMultipleDB;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes=MultipleDbApplication.class)
+@EnableTransactionManagement
+public class JpaMultipleDBIntegrationTest {
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @Autowired
+    private PossessionRepository possessionRepository;
+
+    @Autowired
+    private ProductRepository productRepository;
+
+    // tests
+
+    @Test
+    @Transactional("userTransactionManager")
+    public void whenCreatingUser_thenCreated() {
+        UserMultipleDB user = new UserMultipleDB();
+        user.setName("John");
+        user.setEmail("john@test.com");
+        user.setAge(20);
+        PossessionMultipleDB p = new PossessionMultipleDB("sample");
+        p = possessionRepository.save(p);
+        user.setPossessionList(Collections.singletonList(p));
+        user = userRepository.save(user);
+        final Optional<UserMultipleDB> result = userRepository.findById(user.getId());
+        assertTrue(result.isPresent());
+        System.out.println(result.get().getPossessionList());
+        assertEquals(1, result.get().getPossessionList().size());
+    }
+
+    @Test
+    @Transactional("userTransactionManager")
+    public void whenCreatingUsersWithSameEmail_thenRollback() {
+        UserMultipleDB user1 = new UserMultipleDB();
+        user1.setName("John");
+        user1.setEmail("john@test.com");
+        user1.setAge(20);
+        user1 = userRepository.save(user1);
+        assertTrue(userRepository.findById(user1.getId()).isPresent());
+
+        UserMultipleDB user2 = new UserMultipleDB();
+        user2.setName("Tom");
+        user2.setEmail("john@test.com");
+        user2.setAge(10);
+        try {
+            user2 = userRepository.save(user2);
+            userRepository.flush();
+            fail("DataIntegrityViolationException should be thrown!");
+        } catch (final DataIntegrityViolationException e) {
+            // Expected
+        } catch (final Exception e) {
+            fail("DataIntegrityViolationException should be thrown, instead got: " + e);
+        }
+    }
+
+    @Test
+    @Transactional("productTransactionManager")
+    public void whenCreatingProduct_thenCreated() {
+        ProductMultipleDB product = new ProductMultipleDB();
+        product.setName("Book");
+        product.setId(2);
+        product.setPrice(20);
+        product = productRepository.save(product);
+
+        assertTrue(productRepository.findById(product.getId()).isPresent());
+    }
+
+}

persistence-modules/spring-data-jpa/src/test/java/com/baeldung/util/BaeldungPostgresqlContainer.java

@@ -0,0 +1,35 @@
+package com.baeldung.util;
+
+import org.testcontainers.containers.PostgreSQLContainer;
+
+public class BaeldungPostgresqlContainer extends PostgreSQLContainer<BaeldungPostgresqlContainer> {
+
+    private static final String IMAGE_VERSION = "postgres:11.1";
+
+    private static BaeldungPostgresqlContainer container;
+
+
+    private BaeldungPostgresqlContainer() {
+        super(IMAGE_VERSION);
+    }
+
+    public static BaeldungPostgresqlContainer getInstance() {
+        if (container == null) {
+            container = new BaeldungPostgresqlContainer();
+        }
+        return container;
+    }
+
+    @Override
+    public void start() {
+        super.start();
+        System.setProperty("DB_URL", container.getJdbcUrl());
+        System.setProperty("DB_USERNAME", container.getUsername());
+        System.setProperty("DB_PASSWORD", container.getPassword());
+    }
+
+    @Override
+    public void stop() {
+        //do nothing, JVM handles shut down
+    }
+}

persistence-modules/spring-data-jpa/src/test/java/com/baeldung/util/IDUtil.java

@@ -0,0 +1,33 @@
+package com.baeldung.util;
+
+import java.util.Random;
+
+public final class IDUtil {
+
+    private IDUtil() {
+        throw new AssertionError();
+    }
+
+    // API
+
+    public static String randomPositiveLongAsString() {
+        return Long.toString(randomPositiveLong());
+    }
+
+    public static String randomNegativeLongAsString() {
+        return Long.toString(randomNegativeLong());
+    }
+
+    public static long randomPositiveLong() {
+        long id = new Random().nextLong() * 10000;
+        id = (id < 0) ? (-1 * id) : id;
+        return id;
+    }
+
+    private static long randomNegativeLong() {
+        long id = new Random().nextLong() * 10000;
+        id = (id > 0) ? (-1 * id) : id;
+        return id;
+    }
+
+}

persistence-modules/spring-data-jpa/src/test/java/org/baeldung/SpringContextIntegrationTest.java

@@ -0,0 +1,17 @@
+package org.baeldung;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.boot.Application;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = Application.class)
+public class SpringContextIntegrationTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}

persistence-modules/spring-data-jpa/src/test/java/org/baeldung/SpringContextTest.java

@@ -0,0 +1,17 @@
+package org.baeldung;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.boot.Application;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = Application.class)
+public class SpringContextTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}

persistence-modules/spring-data-jpa/src/test/java/org/baeldung/SpringJpaContextIntegrationTest.java

@@ -0,0 +1,25 @@
+package org.baeldung;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.boot.Application;
+import com.baeldung.boot.config.PersistenceConfiguration;
+import com.baeldung.multipledb.PersistenceProductConfiguration;
+import com.baeldung.multipledb.PersistenceUserConfiguration;
+
+@RunWith(SpringRunner.class)
+@DataJpaTest(excludeAutoConfiguration = {
+        PersistenceConfiguration.class,
+        PersistenceUserConfiguration.class,
+        PersistenceProductConfiguration.class })
+@ContextConfiguration(classes = Application.class)
+public class SpringJpaContextIntegrationTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}