fix spring-data-jpa module

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

@@ -1,13 +1,16 @@
-package com.baeldung.dao.repositories;
+package com.baeldung.boot.daos;
+
+import com.baeldung.boot.Application;
+import com.baeldung.boot.config.PersistenceConfiguration;
+import com.baeldung.boot.daos.ArticleRepository;
+import com.baeldung.boot.domain.Article;
 
-import com.baeldung.config.PersistenceConfiguration;
-import com.baeldung.config.PersistenceProductConfiguration;
-import com.baeldung.config.PersistenceUserConfiguration;
-import com.baeldung.domain.Article;
 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.context.SpringBootTest;
+import org.springframework.context.annotation.Import;
 import org.springframework.test.context.junit4.SpringRunner;
 
 import java.text.SimpleDateFormat;
@@ -18,7 +21,7 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
 @RunWith(SpringRunner.class)
-@DataJpaTest(excludeAutoConfiguration = {PersistenceConfiguration.class, PersistenceUserConfiguration.class, PersistenceProductConfiguration.class})
+@DataJpaTest(properties="spring.datasource.data=classpath:import_entities.sql")
 public class ArticleRepositoryIntegrationTest {
 
     @Autowired

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

@@ -1,7 +1,10 @@
-package com.baeldung.dao.repositories;
+package com.baeldung.boot.daos;
+
+import com.baeldung.boot.Application;
+import com.baeldung.boot.config.PersistenceConfiguration;
+import com.baeldung.boot.daos.ExtendedStudentRepository;
+import com.baeldung.boot.domain.Student;
 
-import com.baeldung.config.PersistenceConfiguration;
-import com.baeldung.domain.Student;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -15,7 +18,7 @@ import java.util.List;
 import static org.assertj.core.api.Assertions.assertThat;
 
 @RunWith(SpringRunner.class)
-@ContextConfiguration(classes = {PersistenceConfiguration.class})
+@ContextConfiguration(classes = {Application.class})
 @DirtiesContext
 public class ExtendedStudentRepositoryIntegrationTest {
     @Resource

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

@@ -1,11 +1,15 @@
-package com.baeldung.dao.repositories;
+package com.baeldung.boot.daos;
+
+import com.baeldung.boot.Application;
+import com.baeldung.boot.config.PersistenceConfiguration;
+import com.baeldung.boot.daos.InventoryRepository;
+import com.baeldung.boot.domain.MerchandiseEntity;
 
-import com.baeldung.config.PersistenceConfiguration;
-import com.baeldung.domain.MerchandiseEntity;
 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.context.SpringBootTest;
 import org.springframework.test.context.junit4.SpringRunner;
 
 import java.math.BigDecimal;
@@ -15,7 +19,7 @@ import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertNotNull;
 
 @RunWith(SpringRunner.class)
-@DataJpaTest(excludeAutoConfiguration = {PersistenceConfiguration.class})
+@SpringBootTest(classes=Application.class)
 public class InventoryRepositoryIntegrationTest {
 
     private static final String ORIGINAL_TITLE = "Pair of Pants";

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

@@ -1,4 +1,4 @@
-package com.baeldung.dao.repositories;
+package com.baeldung.boot.daos;
 
 import static junit.framework.TestCase.assertEquals;
 import static junit.framework.TestCase.assertFalse;
@@ -13,18 +13,24 @@ 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.context.SpringBootTest;
 import org.springframework.test.context.junit4.SpringRunner;
 
-import com.baeldung.config.PersistenceConfiguration;
-import com.baeldung.config.PersistenceProductConfiguration;
-import com.baeldung.config.PersistenceUserConfiguration;
-import com.baeldung.domain.Item;
-import com.baeldung.domain.ItemType;
-import com.baeldung.domain.Location;
-import com.baeldung.domain.Store;
+import com.baeldung.boot.Application;
+import com.baeldung.boot.config.PersistenceConfiguration;
+import com.baeldung.boot.daos.ItemTypeRepository;
+import com.baeldung.boot.daos.LocationRepository;
+import com.baeldung.boot.daos.ReadOnlyLocationRepository;
+import com.baeldung.boot.daos.StoreRepository;
+import com.baeldung.boot.domain.Item;
+import com.baeldung.boot.domain.ItemType;
+import com.baeldung.boot.domain.Location;
+import com.baeldung.boot.domain.Store;
+import com.baeldung.multipledb.PersistenceProductConfiguration;
+import com.baeldung.multipledb.PersistenceUserConfiguration;
 
 @RunWith(SpringRunner.class)
-@DataJpaTest(excludeAutoConfiguration = { PersistenceConfiguration.class, PersistenceUserConfiguration.class, PersistenceProductConfiguration.class })
+@DataJpaTest(properties="spring.datasource.data=classpath:import_entities.sql")
 public class JpaRepositoriesIntegrationTest {
     @Autowired
     private LocationRepository locationRepository;

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

@@ -1,7 +1,8 @@
-package com.baeldung.dao.repositories;
+package com.baeldung.boot.daos;
+
+import com.baeldung.boot.daos.impl.PersonInsertRepository;
+import com.baeldung.boot.domain.Person;
 
-import com.baeldung.dao.repositories.impl.PersonInsertRepository;
-import com.baeldung.domain.Person;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;

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

@@ -0,0 +1,405 @@
+package com.baeldung.boot.daos;
+
+import com.baeldung.boot.domain.User;
+import com.baeldung.boot.user.UserRepository;
+
+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 java.util.*;
+import java.util.stream.Stream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+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;
+
+    @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, USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User(USER_NAME_PETER, USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", 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, USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User(USER_NAME_PETER, USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", USER_EMAIL3, INACTIVE_STATUS));
+
+        userRepository.findAll(new Sort(Sort.Direction.ASC, "name"));
+
+        List<User> usersSortByNameLength = userRepository.findAll(new Sort("LENGTH(name)"));
+
+        assertThat(usersSortByNameLength.get(0)
+          .getName()).isEqualTo(USER_NAME_ADAM);
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindAllSortWithFunctionQueryAnnotationJPQL_ThenReturnUsersSorted() {
+        userRepository.save(new User(USER_NAME_ADAM, USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User(USER_NAME_PETER, USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", USER_EMAIL3, INACTIVE_STATUS));
+
+        userRepository.findAllUsers(new Sort("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, USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User(USER_NAME_PETER, USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", USER_EMAIL3, INACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE1", USER_EMAIL4, INACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE2", USER_EMAIL5, INACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE3", USER_EMAIL6, INACTIVE_STATUS));
+
+        Page<User> usersPage = userRepository.findAllUsersWithPagination(new PageRequest(1, 3));
+
+        assertThat(usersPage.getContent()
+          .get(0)
+          .getName()).isEqualTo("SAMPLE1");
+    }
+
+    @Test
+    public void givenUsersInDB_WhenFindAllWithPageRequestQueryAnnotationNative_ThenReturnPageOfUsers() {
+        userRepository.save(new User(USER_NAME_ADAM, USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User(USER_NAME_PETER, USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", USER_EMAIL3, INACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE1", USER_EMAIL4, INACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE2", USER_EMAIL5, INACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE3", USER_EMAIL6, INACTIVE_STATUS));
+
+        Page<User> usersSortByNameLength = userRepository.findAllUsersWithPaginationNative(new PageRequest(1, 3));
+
+        assertThat(usersSortByNameLength.getContent()
+          .get(0)
+          .getName()).isEqualTo("SAMPLE1");
+    }
+
+    @Test
+    @Transactional
+    public void givenUsersInDB_WhenUpdateStatusForNameModifyingQueryAnnotationJPQL_ThenModifyMatchingUsers() {
+        userRepository.save(new User("SAMPLE", USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE1", USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", USER_EMAIL3, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE3", 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, ACTIVE_STATUS, USER_EMAIL);
+        userRepository.insertUser(USER_NAME_PETER, 1, ACTIVE_STATUS, USER_EMAIL2);
+
+        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);
+    }
+    
+    @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.config.PersistenceConfiguration;
+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 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", USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE1", USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", USER_EMAIL3, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE3", 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/UserRepositoryTCAutoIntegrationTest.java

@@ -0,0 +1,40 @@
+package com.baeldung.boot.daos;
+
+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 static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Created by adam.
+ */
+@RunWith(SpringRunner.class)
+@SpringBootTest
+@ActiveProfiles({"tc", "tc-auto"})
+public class UserRepositoryTCAutoIntegrationTest extends UserRepositoryCommon {
+
+    @ClassRule
+    public static PostgreSQLContainer postgreSQLContainer = BaeldungPostgresqlContainer.getInstance();
+
+    @Test
+    @Transactional
+    public void givenUsersInDB_WhenUpdateStatusForNameModifyingQueryAnnotationNativePostgres_ThenModifyMatchingUsers() {
+        userRepository.save(new User("SAMPLE", USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE1", USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", USER_EMAIL3, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE3", 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/UserRepositoryTCIntegrationTest.java

@@ -0,0 +1,56 @@
+package com.baeldung.boot.daos;
+
+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 com.baeldung.boot.domain.User;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest
+@ActiveProfiles("tc")
+@ContextConfiguration(initializers = {UserRepositoryTCIntegrationTest.Initializer.class})
+public class UserRepositoryTCIntegrationTest 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", USER_EMAIL, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE1", USER_EMAIL2, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE", USER_EMAIL3, ACTIVE_STATUS));
+        userRepository.save(new User("SAMPLE3", 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

@@ -1,7 +1,7 @@
 /**
  *
  */
-package com.baeldung.ddd.event;
+package com.baeldung.boot.ddd.event;
 
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.times;
@@ -15,6 +15,10 @@ 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 {

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

@@ -1,7 +1,7 @@
 /**
  *
  */
-package com.baeldung.ddd.event;
+package com.baeldung.boot.ddd.event;
 
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.times;
@@ -14,6 +14,10 @@ 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 {

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

@@ -1,4 +1,4 @@
-package com.baeldung.ddd.event;
+package com.baeldung.boot.ddd.event;
 
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.times;
@@ -16,6 +16,11 @@ 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 {

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

@@ -1,10 +1,12 @@
 /**
  *
  */
-package com.baeldung.ddd.event;
+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/passenger/PassengerRepositoryIntegrationTest.java

@@ -1,4 +1,4 @@
-package com.baeldung.passenger;
+package com.baeldung.boot.passenger;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.contains;
@@ -24,6 +24,9 @@ import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Sort;
 import org.springframework.test.context.junit4.SpringRunner;
 
+import com.baeldung.boot.passenger.Passenger;
+import com.baeldung.boot.passenger.PassengerRepository;
+
 @DataJpaTest
 @RunWith(SpringRunner.class)
 public class PassengerRepositoryIntegrationTest {

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

@@ -1,6 +1,7 @@
-package com.baeldung.services;
+package com.baeldung.boot.services;
 
-import com.baeldung.domain.Foo;
+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;

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

@@ -1,11 +1,16 @@
-package com.baeldung.services;
+package com.baeldung.boot.services;
+
+import com.baeldung.boot.Application;
+import com.baeldung.boot.config.PersistenceConfiguration;
+import com.baeldung.boot.domain.Foo;
+import com.baeldung.boot.services.IFooService;
+import com.baeldung.boot.services.IOperations;
 
-import com.baeldung.config.PersistenceConfiguration;
-import com.baeldung.domain.Foo;
 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.ContextConfiguration;
@@ -16,7 +21,7 @@ import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
 import static org.junit.Assert.assertNotNull;
 
 @RunWith(SpringRunner.class)
-@ContextConfiguration(classes = {PersistenceConfiguration.class}, loader = AnnotationConfigContextLoader.class)
+@SpringBootTest(classes=Application.class)
 public class FooServicePersistenceIntegrationTest extends AbstractServicePersistenceIntegrationTest<Foo> {
 
     @Autowired

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

@@ -1,4 +1,4 @@
-package com.baeldung.services;
+package com.baeldung.boot.services;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
@@ -16,16 +16,19 @@ 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.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringRunner;
 import org.springframework.test.context.support.AnnotationConfigContextLoader;
 
-import com.baeldung.config.PersistenceConfiguration;
-import com.baeldung.domain.Bar;
+import com.baeldung.boot.Application;
+import com.baeldung.boot.config.PersistenceConfiguration;
+import com.baeldung.boot.domain.Bar;
+import com.baeldung.boot.services.IBarService;
 
 @RunWith(SpringRunner.class)
-@ContextConfiguration(classes = { PersistenceConfiguration.class }, loader = AnnotationConfigContextLoader.class)
+@SpringBootTest(classes=Application.class)
 public class SpringDataJPABarAuditIntegrationTest {
 
     private static Logger logger = LoggerFactory.getLogger(SpringDataJPABarAuditIntegrationTest.class);

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

@@ -1,4 +1,4 @@
-package com.baeldung.services;
+package com.baeldung.multipledb;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
@@ -10,6 +10,7 @@ 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.annotation.DirtiesContext;
 import org.springframework.test.context.ContextConfiguration;
@@ -17,17 +18,17 @@ import org.springframework.test.context.junit4.SpringRunner;
 import org.springframework.transaction.annotation.EnableTransactionManagement;
 import org.springframework.transaction.annotation.Transactional;
 
-import com.baeldung.config.PersistenceProductConfiguration;
-import com.baeldung.config.PersistenceUserConfiguration;
-import com.baeldung.dao.repositories.product.ProductRepository;
-import com.baeldung.dao.repositories.user.PossessionRepository;
-import com.baeldung.dao.repositories.user.UserRepository;
-import com.baeldung.domain.product.Product;
-import com.baeldung.domain.user.Possession;
-import com.baeldung.domain.user.User;
+import com.baeldung.boot.domain.Possession;
+import com.baeldung.boot.domain.User;
+import com.baeldung.boot.user.PossessionRepository;
+import com.baeldung.boot.user.UserRepository;
+import com.baeldung.multipledb.PersistenceProductConfiguration;
+import com.baeldung.multipledb.PersistenceUserConfiguration;
+import com.baeldung.multipledb.Product;
+import com.baeldung.multipledb.ProductRepository;
 
 @RunWith(SpringRunner.class)
-@ContextConfiguration(classes = { PersistenceUserConfiguration.class, PersistenceProductConfiguration.class })
+@SpringBootTest(classes=MultipleDbApplication.class)
 @EnableTransactionManagement
 @DirtiesContext
 public class JpaMultipleDBIntegrationTest {

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

@@ -1,4 +1,4 @@
-package com.baeldung.dao.repositories.product;
+package com.baeldung.multipledb;
 
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.hasSize;
@@ -13,6 +13,7 @@ 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.context.SpringBootTest;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
@@ -22,11 +23,12 @@ import org.springframework.test.context.junit4.SpringRunner;
 import org.springframework.transaction.annotation.EnableTransactionManagement;
 import org.springframework.transaction.annotation.Transactional;
 
-import com.baeldung.config.PersistenceProductConfiguration;
-import com.baeldung.domain.product.Product;
+import com.baeldung.multipledb.PersistenceProductConfiguration;
+import com.baeldung.multipledb.Product;
+import com.baeldung.multipledb.ProductRepository;
 
 @RunWith(SpringRunner.class)
-@ContextConfiguration(classes = { PersistenceProductConfiguration.class })
+@SpringBootTest(classes=MultipleDbApplication.class)
 @EnableTransactionManagement
 public class ProductRepositoryIntegrationTest {
 

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

@@ -5,7 +5,7 @@ import org.junit.runner.RunWith;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.test.context.junit4.SpringRunner;
 
-import com.baeldung.Application;
+import com.baeldung.boot.Application;
 
 @RunWith(SpringRunner.class)
 @SpringBootTest(classes = Application.class)

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

@@ -6,10 +6,10 @@ 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.Application;
-import com.baeldung.config.PersistenceConfiguration;
-import com.baeldung.config.PersistenceProductConfiguration;
-import com.baeldung.config.PersistenceUserConfiguration;
+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 = {