[BAEL-9538] - Move persistence-related modules into the persistence folder

2018-10-20 11:27:08 +05:30
parent 2404312d20
commit 21a3a43788
360 changed files with 1153 additions and 1148 deletions
@@ -0,0 +1,69 @@
+package com.baeldung.dao.repositories;
+
+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.test.context.junit4.SpringRunner;
+
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+@RunWith(SpringRunner.class)
+@DataJpaTest(excludeAutoConfiguration = {PersistenceConfiguration.class, PersistenceUserConfiguration.class, PersistenceProductConfiguration.class})
+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))
+        );
+    }
+
+}
@@ -0,0 +1,39 @@
+package com.baeldung.dao.repositories;
+
+import com.baeldung.config.PersistenceConfiguration;
+import com.baeldung.domain.Student;
+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 javax.annotation.Resource;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(SpringRunner.class)
+@ContextConfiguration(classes = {PersistenceConfiguration.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);
+    }
+}
@@ -0,0 +1,60 @@
+package com.baeldung.dao.repositories;
+
+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.test.context.junit4.SpringRunner;
+
+import java.math.BigDecimal;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringRunner.class)
+@DataJpaTest(excludeAutoConfiguration = {PersistenceConfiguration.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());
+    }
+}
@@ -0,0 +1,96 @@
+package com.baeldung.dao.repositories;
+
+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.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;
+
+@RunWith(SpringRunner.class)
+@DataJpaTest(excludeAutoConfiguration = { PersistenceConfiguration.class, PersistenceUserConfiguration.class, PersistenceProductConfiguration.class })
+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);
+    }
+}
@@ -0,0 +1,378 @@
+package com.baeldung.dao.repositories;
+
+import com.baeldung.config.PersistenceConfiguration;
+import com.baeldung.dao.repositories.user.UserRepository;
+import com.baeldung.domain.user.User;
+import org.junit.After;
+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.Sort;
+import org.springframework.data.jpa.domain.JpaSort;
+import org.springframework.data.mapping.PropertyReferenceException;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Stream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Created by adam.
+ */
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = PersistenceConfiguration.class)
+@DirtiesContext
+public class UserRepositoryIntegrationTest {
+
+    private final String USER_NAME_ADAM = "Adam";
+    private final String USER_NAME_PETER = "Peter";
+
+    private final String USER_EMAIL = "email@example.com";
+    private final String USER_EMAIL2 = "email2@example.com";
+    private final String USER_EMAIL3 = "email3@example.com";
+    private final String USER_EMAIL4 = "email4@example.com";
+    private final String USER_EMAIL5 = "email5@example.com";
+    private final String USER_EMAIL6 = "email6@example.com";
+
+    private final Integer INACTIVE_STATUS = 0;
+    private final Integer ACTIVE_STATUS = 1;
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @Test
+    @Transactional
+    public void givenUsersWithSameNameInDBWhenFindAllByNameThenReturnStreamOfUsers() {
+        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 givenUsersInDBWhenFindAllWithQueryAnnotationThenReturnCollectionWithActiveUsers() {
+        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 givenUsersInDBWhenFindAllWithQueryAnnotationNativeThenReturnCollectionWithActiveUsers() {
+        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 givenUserInDBWhenFindUserByStatusWithQueryAnnotationThenReturnActiveUser() {
+        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 givenUserInDBWhenFindUserByStatusWithQueryAnnotationNativeThenReturnActiveUser() {
+        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 givenUsersInDBWhenFindUserByStatusAndNameWithQueryAnnotationIndexedParamsThenReturnOneUser() {
+        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 givenUsersInDBWhenFindUserByStatusAndNameWithQueryAnnotationNamedParamsThenReturnOneUser() {
+        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 givenUsersInDBWhenFindUserByStatusAndNameWithQueryAnnotationNativeNamedParamsThenReturnOneUser() {
+        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 givenUsersInDBWhenFindUserByStatusAndNameWithQueryAnnotationNamedParamsCustomNamesThenReturnOneUser() {
+        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 givenUsersInDBWhenFindUserByNameLikeWithQueryAnnotationIndexedParamsThenReturnUser() {
+        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 givenUsersInDBWhenFindUserByNameLikeWithQueryAnnotationNamedParamsThenReturnUser() {
+        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 givenUsersInDBWhenFindUserByNameLikeWithQueryAnnotationNativeThenReturnUser() {
+        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 givenUsersInDBWhenFindAllWithSortByNameThenReturnUsersSorted() {
+        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 givenUsersInDBWhenFindAllSortWithFunctionThenThrowException() {
+        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 givenUsersInDBWhenFindAllSortWithFunctionQueryAnnotationJPQLThenReturnUsersSorted() {
+        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 givenUsersInDBWhenFindAllWithPageRequestQueryAnnotationJPQLThenReturnPageOfUsers() {
+        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 givenUsersInDBWhenFindAllWithPageRequestQueryAnnotationNativeThenReturnPageOfUsers() {
+        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 givenUsersInDBWhenUpdateStatusForNameModifyingQueryAnnotationJPQLThenModifyMatchingUsers() {
+        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
+    @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);
+    }
+
+    @After
+    public void cleanUp() {
+        userRepository.deleteAll();
+    }
+
+}
@@ -0,0 +1,68 @@
+/**
+ *
+ */
+package com.baeldung.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;
+
+@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));
+    }
+
+}
@@ -0,0 +1,63 @@
+/**
+ *
+ */
+package com.baeldung.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;
+
+@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));
+    }
+
+}
@@ -0,0 +1,82 @@
+package com.baeldung.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;
+
+@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);
+        }
+    }
+
+}
@@ -0,0 +1,12 @@
+/**
+ *
+ */
+package com.baeldung.ddd.event;
+
+import org.springframework.transaction.event.TransactionalEventListener;
+
+interface TestEventHandler {
+    @TransactionalEventListener
+    void handleEvent(DomainEvent event);
+
+}
@@ -0,0 +1,251 @@
+package com.baeldung.services;
+
+import com.baeldung.domain.Foo;
+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());
+    }
+
+}
@@ -0,0 +1,75 @@
+package com.baeldung.services;
+
+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.dao.DataIntegrityViolationException;
+import org.springframework.dao.InvalidDataAccessApiUsageException;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringRunner.class)
+@ContextConfiguration(classes = {PersistenceConfiguration.class}, loader = AnnotationConfigContextLoader.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;
+    }
+
+}
@@ -0,0 +1,100 @@
+package com.baeldung.services;
+
+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.dao.DataIntegrityViolationException;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.context.ContextConfiguration;
+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;
+
+@RunWith(SpringRunner.class)
+@ContextConfiguration(classes = { PersistenceUserConfiguration.class, PersistenceProductConfiguration.class })
+@EnableTransactionManagement
+@DirtiesContext
+public class JpaMultipleDBIntegrationTest {
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @Autowired
+    private PossessionRepository possessionRepository;
+
+    @Autowired
+    private ProductRepository productRepository;
+
+    // tests
+
+    @Test
+    @Transactional("userTransactionManager")
+    public void whenCreatingUser_thenCreated() {
+        User user = new User();
+        user.setName("John");
+        user.setEmail("john@test.com");
+        user.setAge(20);
+        Possession p = new Possession("sample");
+        p = possessionRepository.save(p);
+        user.setPossessionList(Collections.singletonList(p));
+        user = userRepository.save(user);
+        final Optional<User> 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() {
+        User user1 = new User();
+        user1.setName("John");
+        user1.setEmail("john@test.com");
+        user1.setAge(20);
+        user1 = userRepository.save(user1);
+        assertTrue(userRepository.findById(user1.getId()).isPresent());
+
+        User user2 = new User();
+        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() {
+        Product product = new Product();
+        product.setName("Book");
+        product.setId(2);
+        product.setPrice(20);
+        product = productRepository.save(product);
+
+        assertTrue(productRepository.findById(product.getId()).isPresent());
+    }
+
+}
@@ -0,0 +1,76 @@
+package com.baeldung.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.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;
+
+@RunWith(SpringRunner.class)
+@ContextConfiguration(classes = { PersistenceConfiguration.class }, loader = AnnotationConfigContextLoader.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());
+    }
+}
@@ -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;
+    }
+
+}
@@ -0,0 +1,22 @@
+package org.baeldung;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+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.Application;
+import com.baeldung.config.PersistenceConfiguration;
+import com.baeldung.config.PersistenceProductConfiguration;
+import com.baeldung.config.PersistenceUserConfiguration;
+
+@RunWith(SpringRunner.class)
+@DataJpaTest(excludeAutoConfiguration = {PersistenceConfiguration.class, PersistenceUserConfiguration.class, PersistenceProductConfiguration.class})
+@SpringBootTest(classes = Application.class)
+public class SpringContextIntegrationTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}