Closes #512 - Test KadaiEngine with different ConnectionManagementModes

lib/kadai-core-test/src/test/java/acceptance/common/KadaiEngineAutocommitModeTest.java

@@ -0,0 +1,54 @@
+package acceptance.common;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import acceptance.common.TestUserMapper.TestUser;
+import io.kadai.KadaiConfiguration;
+import io.kadai.common.api.KadaiEngine;
+import io.kadai.common.api.KadaiEngine.ConnectionManagementMode;
+import io.kadai.testapi.KadaiEngineProxy;
+import io.kadai.testapi.extensions.TestContainerExtension;
+import javax.sql.DataSource;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class KadaiEngineAutocommitModeTest {
+
+  private KadaiEngineProxy thisKadaiEngineProxy;
+  private KadaiEngineProxy thatKadaiEngineProxy;
+
+  @BeforeEach
+  public void setupKadaiEngines() throws Exception {
+    String schemaName = TestContainerExtension.determineSchemaName();
+    DataSource dataSource = TestContainerExtension.DATA_SOURCE;
+    KadaiConfiguration kadaiConfiguration =
+        new KadaiConfiguration.Builder(dataSource, false, schemaName, false)
+            .initKadaiProperties()
+            .build();
+    thisKadaiEngineProxy =
+        new KadaiEngineProxy(
+            KadaiEngine.buildKadaiEngine(kadaiConfiguration, ConnectionManagementMode.AUTOCOMMIT));
+    thisKadaiEngineProxy.getSqlSession().getConfiguration().addMapper(TestUserMapper.class);
+
+    thatKadaiEngineProxy = new KadaiEngineProxy(KadaiEngine.buildKadaiEngine(kadaiConfiguration));
+    thatKadaiEngineProxy.getSqlSession().getConfiguration().addMapper(TestUserMapper.class);
+  }
+
+  @Test
+  void should_RetrieveCreated_When_NotManuallyCommited() {
+    TestUserMapper thisMapper =
+        thisKadaiEngineProxy.getSqlSession().getMapper(TestUserMapper.class);
+    TestUserMapper thatMapper =
+        thatKadaiEngineProxy.getSqlSession().getMapper(TestUserMapper.class);
+    TestUser expected = new TestUser("user-1-1", "Max", "Mustermann", "Long name of user-1-1");
+
+    thisKadaiEngineProxy.getEngine().executeInDatabaseConnection(() -> thisMapper.insert(expected));
+
+    TestUser actual =
+        thatKadaiEngineProxy
+            .getEngine()
+            .executeInDatabaseConnection(() -> thatMapper.findById(expected.getId()));
+
+    assertThat(actual).isEqualTo(expected);
+  }
+}

lib/kadai-core-test/src/test/java/acceptance/common/KadaiEngineExplicitModeTest.java

@@ -0,0 +1,83 @@
+package acceptance.common;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import acceptance.common.TestUserMapper.TestUser;
+import io.kadai.KadaiConfiguration;
+import io.kadai.common.api.KadaiEngine;
+import io.kadai.common.api.KadaiEngine.ConnectionManagementMode;
+import io.kadai.testapi.KadaiEngineProxy;
+import io.kadai.testapi.extensions.TestContainerExtension;
+import java.sql.Connection;
+import javax.sql.DataSource;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class KadaiEngineExplicitModeTest {
+
+  private Connection thisConnection;
+  private KadaiEngineProxy thisKadaiEngineProxy;
+  private KadaiEngineProxy thatKadaiEngineProxy;
+
+  @BeforeEach
+  public void setupKadaiEngines() throws Exception {
+    String schemaName = TestContainerExtension.determineSchemaName();
+    DataSource dataSource = TestContainerExtension.DATA_SOURCE;
+    KadaiConfiguration kadaiConfiguration =
+        new KadaiConfiguration.Builder(dataSource, false, schemaName, false)
+            .initKadaiProperties()
+            .build();
+    thisKadaiEngineProxy =
+        new KadaiEngineProxy(
+            KadaiEngine.buildKadaiEngine(kadaiConfiguration, ConnectionManagementMode.EXPLICIT));
+    thisKadaiEngineProxy.getSqlSession().getConfiguration().addMapper(TestUserMapper.class);
+    thisConnection = dataSource.getConnection();
+    thisKadaiEngineProxy.getEngine().getEngine().setConnection(thisConnection);
+
+    thatKadaiEngineProxy = new KadaiEngineProxy(KadaiEngine.buildKadaiEngine(kadaiConfiguration));
+    thatKadaiEngineProxy.getSqlSession().getConfiguration().addMapper(TestUserMapper.class);
+  }
+
+  @AfterEach
+  void cleanConnections() {
+    thisKadaiEngineProxy.getEngine().getEngine().closeConnection();
+  }
+
+  @Test
+  void should_RetrieveCreated_When_Committed() throws Exception {
+    TestUserMapper thisMapper =
+        thisKadaiEngineProxy.getSqlSession().getMapper(TestUserMapper.class);
+    TestUserMapper thatMapper =
+        thatKadaiEngineProxy.getSqlSession().getMapper(TestUserMapper.class);
+    TestUser expected = new TestUser("user-1-1", "Max", "Mustermann", "Long name of user-1-1");
+
+    thisKadaiEngineProxy.getEngine().executeInDatabaseConnection(() -> thisMapper.insert(expected));
+    thisConnection.commit();
+
+    TestUser actual =
+        thatKadaiEngineProxy
+            .getEngine()
+            .executeInDatabaseConnection(() -> thatMapper.findById(expected.getId()));
+
+    assertThat(actual).isEqualTo(expected);
+  }
+
+  @Test
+  void should_NotRetrieveCreated_When_NotCommitted() {
+    TestUserMapper thisMapper =
+        thisKadaiEngineProxy.getSqlSession().getMapper(TestUserMapper.class);
+    TestUserMapper thatMapper =
+        thatKadaiEngineProxy.getSqlSession().getMapper(TestUserMapper.class);
+    TestUser expected = new TestUser("user-1-1", "Max", "Mustermann", "Long name of user-1-1");
+
+    thisKadaiEngineProxy.getEngine().executeInDatabaseConnection(() -> thisMapper.insert(expected));
+
+    TestUser actual =
+        thatKadaiEngineProxy
+            .getEngine()
+            .executeInDatabaseConnection(() -> thatMapper.findById(expected.getId()));
+
+    assertThat(actual).isNull();
+  }
+}

lib/kadai-core-test/src/test/java/acceptance/common/KadaiEngineParticipateModeTest.java

@@ -0,0 +1,54 @@
+package acceptance.common;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import acceptance.common.TestUserMapper.TestUser;
+import io.kadai.KadaiConfiguration;
+import io.kadai.common.api.KadaiEngine;
+import io.kadai.common.api.KadaiEngine.ConnectionManagementMode;
+import io.kadai.testapi.KadaiEngineProxy;
+import io.kadai.testapi.extensions.TestContainerExtension;
+import javax.sql.DataSource;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class KadaiEngineParticipateModeTest {
+
+  private KadaiEngineProxy thisKadaiEngineProxy;
+  private KadaiEngineProxy thatKadaiEngineProxy;
+
+  @BeforeEach
+  public void setupKadaiEngines() throws Exception {
+    String schemaName = TestContainerExtension.determineSchemaName();
+    DataSource dataSource = TestContainerExtension.DATA_SOURCE;
+    KadaiConfiguration kadaiConfiguration =
+        new KadaiConfiguration.Builder(dataSource, false, schemaName, false)
+            .initKadaiProperties()
+            .build();
+    thisKadaiEngineProxy =
+        new KadaiEngineProxy(
+            KadaiEngine.buildKadaiEngine(kadaiConfiguration, ConnectionManagementMode.PARTICIPATE));
+    thisKadaiEngineProxy.getSqlSession().getConfiguration().addMapper(TestUserMapper.class);
+
+    thatKadaiEngineProxy = new KadaiEngineProxy(KadaiEngine.buildKadaiEngine(kadaiConfiguration));
+    thatKadaiEngineProxy.getSqlSession().getConfiguration().addMapper(TestUserMapper.class);
+  }
+
+  @Test
+  void should_NotRetrieveCreated_When_NotCommitted() {
+    TestUserMapper thisMapper =
+        thisKadaiEngineProxy.getSqlSession().getMapper(TestUserMapper.class);
+    TestUserMapper thatMapper =
+        thatKadaiEngineProxy.getSqlSession().getMapper(TestUserMapper.class);
+    TestUser expected = new TestUser("user-1-1", "Max", "Mustermann", "Long name of user-1-1");
+
+    thisKadaiEngineProxy.getEngine().executeInDatabaseConnection(() -> thisMapper.insert(expected));
+
+    TestUser actual =
+        thatKadaiEngineProxy
+            .getEngine()
+            .executeInDatabaseConnection(() -> thatMapper.findById(expected.getId()));
+
+    assertThat(actual).isNull();
+  }
+}

lib/kadai-core-test/src/test/java/acceptance/common/KadaiEngineTest.java

@@ -25,27 +25,61 @@
 import io.kadai.common.api.KadaiEngine.ConnectionManagementMode;
 import io.kadai.common.internal.configuration.DbSchemaCreator;
 import io.kadai.testapi.extensions.TestContainerExtension;
+import javax.sql.DataSource;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.EnumSource;
 
 class KadaiEngineTest {
 
-  @ParameterizedTest
-  @EnumSource(ConnectionManagementMode.class)
-  void should_CreateKadaiEngine_When_GivenConnectionManagementModeIsActive(
-      ConnectionManagementMode connectionManagementMode) throws Exception {
+  private KadaiEngine kadaiEngine;
 
+  @BeforeEach
+  public void setupKadaiEngine() throws Exception {
     String schemaName = TestContainerExtension.determineSchemaName();
-
+    DataSource dataSource = TestContainerExtension.DATA_SOURCE;
     KadaiConfiguration kadaiConfiguration =
-        new KadaiConfiguration.Builder(TestContainerExtension.DATA_SOURCE, false, schemaName, true)
+        new KadaiConfiguration.Builder(dataSource, false, schemaName, false)
             .initKadaiProperties()
             .build();
+    this.kadaiEngine = KadaiEngine.buildKadaiEngine(kadaiConfiguration);
+  }
 
-    KadaiEngine.buildKadaiEngine(kadaiConfiguration, connectionManagementMode);
+  @Test
+  void should_DefaultToParticipateMode_When_BuildingKadaiEngineJustByConfiguration() {
+    assertThat(kadaiEngine.getConnectionManagementMode())
+        .isEqualTo(ConnectionManagementMode.PARTICIPATE);
+  }
+
+  @ParameterizedTest
+  @EnumSource(ConnectionManagementMode.class)
+  void should_CreateKadaiEngine_For_ConnectionManagementMode(ConnectionManagementMode mode) {
+    kadaiEngine.setConnectionManagementMode(mode);
 
     DbSchemaCreator dsc =
-        new DbSchemaCreator(kadaiConfiguration.getDataSource(), kadaiConfiguration.getSchemaName());
+        new DbSchemaCreator(
+            kadaiEngine.getConfiguration().getDataSource(),
+            kadaiEngine.getConfiguration().getSchemaName());
+
     assertThat(dsc.isValidSchemaVersion(KadaiEngine.MINIMAL_KADAI_SCHEMA_VERSION)).isTrue();
   }
+
+  @ParameterizedTest
+  @EnumSource(ConnectionManagementMode.class)
+  void should_SetModeExplicit_When_SetConnection(ConnectionManagementMode mode) throws Exception {
+    kadaiEngine.setConnectionManagementMode(mode);
+    kadaiEngine.setConnection(kadaiEngine.getConfiguration().getDataSource().getConnection());
+
+    assertThat(kadaiEngine.getConnectionManagementMode())
+        .isEqualTo(ConnectionManagementMode.EXPLICIT);
+  }
+
+  @Test
+  void should_SetModeParticipate_When_CloseConnectionForModeExplicit() {
+    kadaiEngine.closeConnection();
+
+    assertThat(kadaiEngine.getConnectionManagementMode())
+        .isEqualTo(ConnectionManagementMode.PARTICIPATE);
+  }
 }

lib/kadai-core-test/src/test/java/acceptance/common/TestUserMapper.java

@@ -0,0 +1,91 @@
+package acceptance.common;
+
+import static io.kadai.common.internal.util.SqlProviderUtil.CLOSING_SCRIPT_TAG;
+import static io.kadai.common.internal.util.SqlProviderUtil.DB2_WITH_UR;
+import static io.kadai.common.internal.util.SqlProviderUtil.OPENING_SCRIPT_TAG;
+
+import java.util.Objects;
+import org.apache.ibatis.annotations.Insert;
+import org.apache.ibatis.annotations.Result;
+import org.apache.ibatis.annotations.Select;
+
+interface TestUserMapper {
+
+  String USER_INFO_COLUMNS = "USER_ID, FIRST_NAME, LASTNAME, LONG_NAME";
+  String USER_INFO_VALUES = "#{id}, #{firstName}, #{lastName}, #{longName}";
+
+  @Select(
+      OPENING_SCRIPT_TAG
+          + "SELECT "
+          + USER_INFO_COLUMNS
+          + " FROM USER_INFO "
+          + " WHERE USER_ID = #{id} "
+          + DB2_WITH_UR
+          + CLOSING_SCRIPT_TAG)
+  @Result(property = "id", column = "USER_ID")
+  @Result(property = "firstName", column = "FIRST_NAME")
+  @Result(property = "lastName", column = "LASTNAME")
+  @Result(property = "longName", column = "LONG_NAME")
+  TestUser findById(String id);
+
+  @Insert("INSERT INTO USER_INFO ( " + USER_INFO_COLUMNS + ") VALUES(" + USER_INFO_VALUES + ")")
+  void insert(TestUser user);
+
+  class TestUser {
+    private String id;
+    private String firstName;
+    private String lastName;
+    private String longName;
+
+    public String getId() {
+      return id;
+    }
+
+    public void setId(String id) {
+      this.id = id;
+    }
+
+    public TestUser(String id, String firstName, String lastName, String longName) {
+      this.id = id;
+      this.firstName = firstName;
+      this.lastName = lastName;
+      this.longName = longName;
+    }
+
+    @Override
+    public String toString() {
+      return "TestUser [id="
+          + id
+          + ", firstName="
+          + firstName
+          + ", lastName="
+          + lastName
+          + ", longName="
+          + longName
+          + "]";
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+      if (this == obj) {
+        return true;
+      }
+      if (obj == null) {
+        return false;
+      }
+      if (getClass() != obj.getClass()) {
+        return false;
+      }
+      TestUser other = (TestUser) obj;
+      return Objects.equals(id, other.id)
+          && Objects.equals(firstName, other.firstName)
+          && Objects.equals(lastName, other.lastName)
+          && Objects.equals(longName, other.longName);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(id, firstName, lastName, longName);
+    }
+  }
+}