Switch from Postgres to H2

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/Application.java

@@ -0,0 +1,12 @@
+package com.baeldung;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class Application {
+
+    public static void main(String[] args) {
+        SpringApplication.run(Application.class, args);
+    }
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/model/Payment.java

@@ -0,0 +1,55 @@
+package com.baeldung.model;
+
+import javax.persistence.*;
+
+@Entity
+public class Payment {
+
+    @Id
+    @GeneratedValue
+    private Long id;
+
+    private Long amount;
+
+    @Column(unique = true)
+    private String referenceNumber;
+
+    @Enumerated(EnumType.STRING)
+    private State state;
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Long getAmount() {
+        return amount;
+    }
+
+    public void setAmount(Long amount) {
+        this.amount = amount;
+    }
+
+    public String getReferenceNumber() {
+        return referenceNumber;
+    }
+
+    public void setReferenceNumber(String referenceNumber) {
+        this.referenceNumber = referenceNumber;
+    }
+
+    public State getState() {
+        return state;
+    }
+
+    public void setState(State state) {
+        this.state = state;
+    }
+
+    public enum State {
+        STARTED, FAILED, SUCCESSFUL
+    }
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/model/User.java

@@ -0,0 +1,42 @@
+package com.baeldung.model;
+
+import javax.persistence.*;
+import java.util.Set;
+
+@Entity
+@Table(name = "users")
+public class User {
+
+    @Id
+    @GeneratedValue
+    private Long id;
+
+    private String username;
+
+    @ElementCollection
+    private Set<String> permissions;
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public Set<String> getPermissions() {
+        return permissions;
+    }
+
+    public void setPermissions(Set<String> permissions) {
+        this.permissions = permissions;
+    }
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/repository/UserRepository.java

@@ -0,0 +1,17 @@
+package com.baeldung.repository;
+
+import com.baeldung.model.User;
+import org.springframework.data.jpa.repository.EntityGraph;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface UserRepository extends JpaRepository<User, Long> {
+
+    @EntityGraph(attributePaths = "permissions")
+    Optional<User> findDetailedByUsername(String username);
+
+    Optional<User> findSummaryByUsername(String username);
+
+    Optional<User> findByUsername(String username);
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/service/SimpleUserService.java

@@ -0,0 +1,24 @@
+package com.baeldung.service;
+
+import com.baeldung.model.User;
+import com.baeldung.repository.UserRepository;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Optional;
+
+@Service
+public class SimpleUserService implements UserService {
+
+    private final UserRepository userRepository;
+
+    public SimpleUserService(UserRepository userRepository) {
+        this.userRepository = userRepository;
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Optional<User> findOne(String username) {
+        return userRepository.findDetailedByUsername(username);
+    }
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/service/UserService.java

@@ -0,0 +1,9 @@
+package com.baeldung.service;
+
+import com.baeldung.model.User;
+
+import java.util.Optional;
+
+public interface UserService {
+    Optional<User> findOne(String username);
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/web/DetailedUserDto.java

@@ -0,0 +1,45 @@
+package com.baeldung.web;
+
+import com.baeldung.model.User;
+
+import java.util.Set;
+
+public class DetailedUserDto {
+
+    private Long id;
+    private String username;
+    private Set<String> permissions;
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public Set<String> getPermissions() {
+        return permissions;
+    }
+
+    public void setPermissions(Set<String> permissions) {
+        this.permissions = permissions;
+    }
+
+    public static DetailedUserDto fromEntity(User user) {
+        DetailedUserDto detailed = new DetailedUserDto();
+        detailed.setId(user.getId());
+        detailed.setUsername(user.getUsername());
+        detailed.setPermissions(user.getPermissions());
+
+        return detailed;
+    }
+}

persistence-modules/spring-data-jpa-3/src/main/java/com/baeldung/web/UserController.java

@@ -0,0 +1,27 @@
+package com.baeldung.web;
+
+import com.baeldung.service.UserService;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/users")
+public class UserController {
+
+    private final UserService userService;
+
+    public UserController(UserService userService) {
+        this.userService = userService;
+    }
+
+    @GetMapping("/{username}")
+    public ResponseEntity<?> findOne(@PathVariable String username) {
+        return userService.findOne(username)
+                .map(DetailedUserDto::fromEntity)
+                .map(ResponseEntity::ok)
+                .orElse(ResponseEntity.notFound().build());
+    }
+}

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/osiv/UserControllerIntegrationTest.java

@@ -0,0 +1,54 @@
+package com.baeldung.osiv;
+
+import com.baeldung.model.User;
+import com.baeldung.repository.UserRepository;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.web.servlet.MockMvc;
+
+import java.util.Arrays;
+import java.util.HashSet;
+
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@SpringBootTest
+@AutoConfigureMockMvc
+@ActiveProfiles("test")
+class UserControllerIntegrationTest {
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @BeforeEach
+    void setUp() {
+        User user = new User();
+        user.setUsername("root");
+        user.setPermissions(new HashSet<>(Arrays.asList("PERM_READ", "PERM_WRITE")));
+
+        userRepository.save(user);
+    }
+
+    @Test
+    void givenTheUserExists_WhenOsivIsEnabled_ThenLazyInitWorkEverywhere() throws Exception {
+        mockMvc.perform(get("/users/root"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.username").value("root"))
+                .andExpect(jsonPath("$.permissions", containsInAnyOrder("PERM_READ", "PERM_WRITE")));
+    }
+
+    @AfterEach
+    void flushDb() {
+        userRepository.deleteAll();
+    }
+}

persistence-modules/spring-data-jpa-3/src/test/java/com/baeldung/tx/ManualTransactionIntegrationTest.java

@@ -0,0 +1,152 @@
+package com.baeldung.tx;
+
+import com.baeldung.model.Payment;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.TransactionDefinition;
+import org.springframework.transaction.TransactionStatus;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.support.DefaultTransactionDefinition;
+import org.springframework.transaction.support.TransactionCallbackWithoutResult;
+import org.springframework.transaction.support.TransactionTemplate;
+
+import javax.persistence.EntityManager;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.springframework.transaction.annotation.Propagation.NOT_SUPPORTED;
+
+@DataJpaTest
+@ActiveProfiles("test")
+@Transactional(propagation = NOT_SUPPORTED)
+class ManualTransactionIntegrationTest {
+
+    @Autowired
+    private PlatformTransactionManager transactionManager;
+
+    @Autowired
+    private EntityManager entityManager;
+
+    private TransactionTemplate transactionTemplate;
+
+    @BeforeEach
+    void setUp() {
+        transactionTemplate = new TransactionTemplate(transactionManager);
+    }
+
+    @AfterEach
+    void flushDb() {
+        transactionTemplate.execute(status -> entityManager
+                .createQuery("delete from Payment")
+                .executeUpdate());
+    }
+
+    @Test
+    void givenAPayment_WhenNotDuplicate_ThenShouldCommit() {
+        Long id = transactionTemplate.execute(status -> {
+            Payment payment = new Payment();
+            payment.setAmount(1000L);
+            payment.setReferenceNumber("Ref-1");
+            payment.setState(Payment.State.SUCCESSFUL);
+
+            entityManager.persist(payment);
+
+            return payment.getId();
+        });
+
+        Payment payment = entityManager.find(Payment.class, id);
+        assertThat(payment).isNotNull();
+    }
+
+    @Test
+    void givenAPayment_WhenMarkAsRollback_ThenShouldRollback() {
+        transactionTemplate.execute(status -> {
+            Payment payment = new Payment();
+            payment.setAmount(1000L);
+            payment.setReferenceNumber("Ref-1");
+            payment.setState(Payment.State.SUCCESSFUL);
+
+            entityManager.persist(payment);
+            status.setRollbackOnly();
+
+            return payment.getId();
+        });
+
+        assertThat(entityManager
+                .createQuery("select p from Payment p")
+                .getResultList()).isEmpty();
+    }
+
+    @Test
+    void givenTwoPayments_WhenRefIsDuplicate_ThenShouldRollback() {
+        try {
+            transactionTemplate.execute(s -> {
+                Payment first = new Payment();
+                first.setAmount(1000L);
+                first.setReferenceNumber("Ref-1");
+                first.setState(Payment.State.SUCCESSFUL);
+
+                Payment second = new Payment();
+                second.setAmount(2000L);
+                second.setReferenceNumber("Ref-1");
+                second.setState(Payment.State.SUCCESSFUL);
+
+                entityManager.persist(first);
+                entityManager.persist(second);
+
+                return "Ref-1";
+            });
+        } catch (Exception ignored) {
+        }
+
+        assertThat(entityManager
+                .createQuery("select p from Payment p")
+                .getResultList()).isEmpty();
+    }
+
+    @Test
+    void givenAPayment_WhenNotExpectingAnyResult_ThenShouldCommit() {
+        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
+            @Override
+            protected void doInTransactionWithoutResult(TransactionStatus status) {
+                Payment payment = new Payment();
+                payment.setReferenceNumber("Ref-1");
+                payment.setState(Payment.State.SUCCESSFUL);
+
+                entityManager.persist(payment);
+            }
+        });
+
+        assertThat(entityManager
+                .createQuery("select p from Payment p")
+                .getResultList()).hasSize(1);
+    }
+
+    @Test
+    void givenAPayment_WhenUsingTxManager_ThenShouldCommit() {
+        DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
+        definition.setIsolationLevel(TransactionDefinition.ISOLATION_REPEATABLE_READ);
+        definition.setTimeout(3);
+
+        TransactionStatus status = transactionManager.getTransaction(definition);
+        try {
+            Payment payment = new Payment();
+            payment.setReferenceNumber("Ref-1");
+            payment.setState(Payment.State.SUCCESSFUL);
+
+            entityManager.persist(payment);
+            transactionManager.commit(status);
+        } catch (Exception ex) {
+            transactionManager.rollback(status);
+        }
+
+        assertThat(entityManager
+                .createQuery("select p from Payment p")
+                .getResultList()).hasSize(1);
+    }
+
+}

persistence-modules/spring-data-jpa-3/src/test/resources/application-test.properties

@@ -0,0 +1 @@
+spring.jpa.hibernate.ddl-auto=update