How to use jodd.db.jtx

/**
 * Creates JTX transaction manager.
 */
protected JtxTransactionManager createJtxTransactionManager(final ConnectionProvider connectionProvider) {
  return new DbJtxTransactionManager(connectionProvider);
}

/**
 * Builds new transaction instance.
 */
@Override
protected JtxTransaction createNewTransaction(final JtxTransactionMode tm, final Object scope, final boolean active) {
  return new DbJtxTransaction(this, tm, scope, active);
}

/**
 * Creates db jtx manager and registers new {@link DbJtxResourceManager}.
 */
public DbJtxTransactionManager(final ConnectionProvider connectionProvider) {
  this(new DbJtxResourceManager(connectionProvider));
}

void service0() {
  assertTotals(0, 0);
  DbJtxTransaction tx = dbtxm.requestTransaction(new JtxTransactionMode(JtxPropagationBehavior.PROPAGATION_REQUIRED, true));
  assertTotals(1, 1);
  s0 = tx.requestResource();
  service0_1(tx);
  tx.commit();
  assertTotals(0, 0);
}

JtxTransaction service1() {
  assertTotals(0, 0);
  DbJtxTransaction tx = dbtxm.requestTransaction(new JtxTransactionMode(JtxPropagationBehavior.PROPAGATION_REQUIRED, true));
  assertTotals(1, 1);
  s1 = tx.requestResource();
  return tx;
}

@Test
void testRequiredToNever() {
  LeanJtxWorker worker = new LeanJtxWorker(dbtxm);
  DbJtxSessionProvider sessionProvider = new DbJtxSessionProvider(worker.getTransactionManager());
  // session #1: required
  JtxTransaction jtx = worker.maybeRequestTransaction(required(), CTX_1);
  assertNotNull(jtx);
  DbSession session1 = sessionProvider.getDbSession();
  executeUpdate(session1, "insert into GIRL values(1, 'Sophia', null)");
  assertTrue(jtx.isActive());
  assertFalse(jtx.isCommitted());
  assertFalse(jtx.isNoTransaction());
  // session #2: inner, never
  try {
    worker.maybeRequestTransaction(never(), CTX_2);
    fail("error");
  } catch (JtxException ignore) {
  }
}

/**
 * Creates db jtx manager and registers provided {@link DbJtxResourceManager}.
 */
public DbJtxTransactionManager(final DbJtxResourceManager resourceManager) {
  setMaxResourcesPerTransaction(1);
  setSingleResourceManager(true);
  super.registerResourceManager(resourceManager);
}

public DbSession requestResource() {
  return requestResource(DbSession.class);
}

/**
 * {@inheritDoc}
 */
public DbSession beginTransaction(final JtxTransactionMode jtxMode, final boolean active) {
  DbSession session = new DbSession(connectionProvider);
  if (active) {
    log.debug("begin jtx");
    session.beginTransaction(JtxDbUtil.convertToDbMode(jtxMode));
  }
  return session;
}

  @AfterEach
  void tearDown() {
    dbtxm.close();
//        cp.close();
    dbtxm = null;
  }

public void assertTotals(int total, int totalActive) {
  assertEquals(total, dbtxm.totalThreadTransactions());
  assertEquals(totalActive, dbtxm.totalActiveThreadTransactions());
}

@Test
void testAction() {
  assertNotNull(dbtxm);
  assertTotals(0, 0);
  assertEquals(0, dbtxm.totalThreadTransactions());
  service0();
  JtxTransaction tx1 = service1();
  service2(tx1);
  service3(tx1);
  tx1.commit();
  assertTotals(0, 0);
}

void service3_1(JtxTransaction tx3) {
  assertTotals(1, 1);
  DbJtxTransaction tx = dbtxm.requestTransaction(new JtxTransactionMode(JtxPropagationBehavior.PROPAGATION_NOT_SUPPORTED, true));
  assertNotSame(tx3, tx);
  assertTotals(2, 1);
  assertNotSame(s1, tx.requestResource());
  assertNotSame(s1, tx.requestResource());
  tx.commit();
  assertTotals(1, 1);
}

void service0_1(JtxTransaction uptx) {
  assertTotals(1, 1);
  DbJtxTransaction tx = dbtxm.requestTransaction(new JtxTransactionMode(JtxPropagationBehavior.PROPAGATION_SUPPORTS, true));
  assertTotals(1, 1);
  assertEquals(uptx, tx);
  DbSession s1 = tx.requestResource();
  assertEquals(s0, s1);
}

@Test
void testSupportsToMandatory() {
  LeanJtxWorker worker = new LeanJtxWorker(dbtxm);
  DbJtxSessionProvider sessionProvider = new DbJtxSessionProvider(worker.getTransactionManager());
  // session #1: supports
  JtxTransaction jtx = worker.maybeRequestTransaction(supports(), CTX_1);
  assertNotNull(jtx);
  assertFalse(jtx.isActive());
  DbSession session1 = sessionProvider.getDbSession();
  executeUpdate(session1, "insert into GIRL values(1, 'Sophia', null)");
  assertFalse(jtx.isActive());
  assertFalse(jtx.isCommitted());
  assertTrue(jtx.isNoTransaction());
  // session #2: inner, mandatory
  try {
    worker.maybeRequestTransaction(mandatory(), CTX_2);
    fail("error");
  } catch (JtxException ignore) {
  }
}

/**
 * Returns session from JTX transaction manager and started transaction.
 */
@Override
public DbSession getDbSession() {
  log.debug("Requesting db TX manager session");
  final DbJtxTransaction jtx = (DbJtxTransaction) jtxTxManager.getTransaction();
  if (jtx == null) {
    throw new DbSqlException(
        "No transaction is in progress and DbSession can't be provided. " +
        "It seems that transaction manager is not used to begin a transaction.");
  }
  return jtx.requestResource();
}

@ParameterizedTest
@MethodSource(value = "testData_testConvertToDbMode")
void testConvertToDbMode(final DbTransactionMode expected, final JtxTransactionMode input) {
  final DbTransactionMode actual = JtxDbUtil.convertToDbMode(input);
  // asserts
  assertNotNull(actual);
  assertTrue(expected.equals(actual));
}

@AfterEach
protected void tearDown() throws Exception {
  dbtxm.close();
  dbtxm = null;
  DbOom.get().shutdown();
}

void service2(JtxTransaction tx1) {
  assertTotals(1, 1);
  DbJtxTransaction tx = dbtxm.requestTransaction(new JtxTransactionMode(JtxPropagationBehavior.PROPAGATION_REQUIRES_NEW, true));
  assertTotals(2, 2);
  assertNotSame(tx1, tx);
  assertNotSame(s1, tx.requestResource());
  tx.commit();
  assertTotals(1, 1);
}

void service3(JtxTransaction tx1) {
  assertTotals(1, 1);
  DbJtxTransaction tx = dbtxm.requestTransaction(new JtxTransactionMode(JtxPropagationBehavior.PROPAGATION_REQUIRED, true));
  assertEquals(tx1, tx);
  assertTotals(1, 1);
  assertEquals(s1, tx.requestResource());
  service3_1(tx);
  assertEquals(s1, tx.requestResource());
  assertTotals(1, 1);
}