jodd.db.jtx.DbJtxSessionProvider.<init> java code examples

final DbSessionProvider sessionProvider = new DbJtxSessionProvider(jtxManager);

@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) {
  }
}

@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) {
  }
}

@Test
void testSupportsNone() {
  LeanJtxWorker worker = new LeanJtxWorker(dbtxm);
  DbJtxSessionProvider sessionProvider = new DbJtxSessionProvider(worker.getTransactionManager());
  // session #1: supports - commit
  JtxTransaction jtx = worker.maybeRequestTransaction(supports(), CTX_1);
  assertNotNull(jtx);
  DbSession session = sessionProvider.getDbSession();
  executeUpdate(session, "insert into GIRL values(1, 'Sophia', null)");
  assertFalse(jtx.isActive());
  assertFalse(jtx.isCommitted());
  assertTrue(jtx.isNoTransaction());
  assertTrue(worker.maybeCommitTransaction(jtx));
  assertFalse(jtx.isActive());
  assertTrue(jtx.isCommitted());
  // session #2: required - rollback
  jtx = worker.maybeRequestTransaction(supports(), CTX_2);
  assertNotNull(jtx);
  session = sessionProvider.getDbSession();
  executeUpdate(session, "insert into GIRL values(2, 'Gloria', null)");
  assertTrue(worker.markOrRollbackTransaction(jtx, null));
  // test
  session = new DbSession(cp);
  assertEquals(1, executeCount(session, "select count(*) from GIRL where id = 1"));
  assertEquals(1, executeCount(session, "select count(*) from GIRL where id = 2"));
  session.closeSession();
}

@Test
void testRequiredToSupportsCommit() {
  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, supports
  JtxTransaction jtx2 = worker.maybeRequestTransaction(supports(), CTX_2);
  assertNull(jtx2);
  DbSession session2 = sessionProvider.getDbSession();
  assertSame(session1, session2);
  executeUpdate(session2, "insert into GIRL values(2, 'Gloria', null)");
  assertFalse(worker.maybeCommitTransaction(jtx2));
  assertTrue(jtx.isActive());
  // session #1: commit
  assertTrue(worker.maybeCommitTransaction(jtx));
  assertFalse(jtx.isActive());
  assertTrue(jtx.isCommitted());
  // test
  session1 = new DbSession(cp);
  assertEquals(1, executeCount(session1, "select count(*) from GIRL where id = 1"));
  assertEquals(1, executeCount(session1, "select count(*) from GIRL where id = 2"));
  session1.closeSession();
}

@Test
void testNotSupported() {
  LeanJtxWorker worker = new LeanJtxWorker(dbtxm);
  DbJtxSessionProvider sessionProvider = new DbJtxSessionProvider(worker.getTransactionManager());
  // session #1: not supported - commit
  JtxTransaction jtx = worker.maybeRequestTransaction(notSupported(), CTX_1);
  assertNotNull(jtx);
  DbSession session = sessionProvider.getDbSession();
  executeUpdate(session, "insert into GIRL values(1, 'Sophia', null)");
  assertFalse(jtx.isActive());
  assertTrue(jtx.isNoTransaction());
  assertTrue(worker.maybeCommitTransaction(jtx));
  assertFalse(jtx.isActive());
  assertTrue(jtx.isCommitted());
  // session #2: not supported - rollback
  jtx = worker.maybeRequestTransaction(notSupported(), CTX_2);
  assertNotNull(jtx);
  session = sessionProvider.getDbSession();
  assertFalse(jtx.isActive());
  assertTrue(jtx.isNoTransaction());
  executeUpdate(session, "insert into GIRL values(2, 'Gloria', null)");
  assertTrue(worker.markOrRollbackTransaction(jtx, null));
  // test
  session = new DbSession(cp);
  assertEquals(1, executeCount(session, "select count(*) from GIRL where id = 1"));
  assertEquals(1, executeCount(session, "select count(*) from GIRL where id = 2"));
  session.closeSession();
}

@Test
void testRequiredToMandatoryCommit() {
  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, mandatory
  JtxTransaction jtx2 = worker.maybeRequestTransaction(mandatory(), CTX_2);
  assertNull(jtx2);
  DbSession session2 = sessionProvider.getDbSession();
  assertSame(session1, session2);
  executeUpdate(session2, "insert into GIRL values(2, 'Gloria', null)");
  assertFalse(worker.maybeCommitTransaction(jtx2));
  assertTrue(jtx.isActive());
  // session #1: commit
  assertTrue(worker.maybeCommitTransaction(jtx));
  assertFalse(jtx.isActive());
  assertTrue(jtx.isCommitted());
  // test
  session1 = new DbSession(cp);
  assertEquals(1, executeCount(session1, "select count(*) from GIRL where id = 1"));
  assertEquals(1, executeCount(session1, "select count(*) from GIRL where id = 2"));
  session1.closeSession();
}

@Test
void testRequiredToRequiredCommit() {
  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, required
  JtxTransaction jtx2 = worker.maybeRequestTransaction(required(), CTX_2);
  assertNull(jtx2);
  DbSession session2 = sessionProvider.getDbSession();
  assertSame(session1, session2);
  executeUpdate(session2, "insert into GIRL values(2, 'Gloria', null)");
  assertFalse(worker.maybeCommitTransaction(jtx2));
  assertTrue(jtx.isActive());
  // session #1: commit
  assertTrue(worker.maybeCommitTransaction(jtx));
  assertFalse(jtx.isActive());
  assertTrue(jtx.isCommitted());
  // test
  session1 = new DbSession(cp);
  assertEquals(1, executeCount(session1, "select count(*) from GIRL where id = 1"));
  assertEquals(1, executeCount(session1, "select count(*) from GIRL where id = 2"));
  session1.closeSession();
}

@Test
void testRequired() {
  LeanJtxWorker worker = new LeanJtxWorker(dbtxm);
  DbJtxSessionProvider sessionProvider = new DbJtxSessionProvider(worker.getTransactionManager());
  // session #1: required - commit
  JtxTransaction jtx = worker.maybeRequestTransaction(required(), CTX_1);
  assertTrue(jtx.isActive());
  assertNotNull(jtx);
  DbSession session = sessionProvider.getDbSession();
  executeUpdate(session, "insert into GIRL values(1, 'Sophia', null)");
  assertTrue(jtx.isActive());
  assertFalse(jtx.isCommitted());
  assertFalse(jtx.isNoTransaction());
  assertTrue(worker.maybeCommitTransaction(jtx));
  assertFalse(jtx.isActive());
  assertTrue(jtx.isCommitted());
  assertFalse(jtx.isNoTransaction());
  // session #2: required - rollback
  jtx = worker.maybeRequestTransaction(required(), CTX_1);
  assertNotNull(jtx);
  session = sessionProvider.getDbSession();
  executeUpdate(session, "insert into GIRL values(2, 'Gloria', null)");
  assertTrue(worker.markOrRollbackTransaction(jtx, null));
  // test
  session = new DbSession(cp);
  assertEquals(1, executeCount(session, "select count(*) from GIRL where id = 1"));
  assertEquals(0, executeCount(session, "select count(*) from GIRL where id = 2"));
  session.closeSession();
}

@Test
void testSupportsToRequiredCommit() {
  LeanJtxWorker worker = new LeanJtxWorker(dbtxm);
  DbJtxSessionProvider sessionProvider = new DbJtxSessionProvider(worker.getTransactionManager());

@Test
void testSupportsToSupportsCommit() {
  LeanJtxWorker worker = new LeanJtxWorker(dbtxm);
  DbJtxSessionProvider sessionProvider = new DbJtxSessionProvider(worker.getTransactionManager());

@Test
void testSupportsToNeverCommit() {
  LeanJtxWorker worker = new LeanJtxWorker(dbtxm);
  DbJtxSessionProvider sessionProvider = new DbJtxSessionProvider(worker.getTransactionManager());

@Test
void testSupportsToRequiresNewCommit() {
  LeanJtxWorker worker = new LeanJtxWorker(dbtxm);
  DbJtxSessionProvider sessionProvider = new DbJtxSessionProvider(worker.getTransactionManager());

@Test
void testRequiredToRequiredRollback() {
  LeanJtxWorker worker = new LeanJtxWorker(dbtxm);
  DbJtxSessionProvider sessionProvider = new DbJtxSessionProvider(worker.getTransactionManager());

DbJtxSessionProvider sessionProvider = new DbJtxSessionProvider(jtxManager);

final DbSessionProvider sessionProvider = new DbJtxSessionProvider(jtxManager);

Javadoc

Creates new JTX session provider.

Popular methods of DbJtxSessionProvider

getDbSession
Returns session from JTX transaction manager and started transaction.

Popular in Java

Parsing JSON documents to java classes using gson
scheduleAtFixedRate (Timer)
findViewById (Activity)
setScale (BigDecimal)
Font (java.awt)
The Font class represents fonts, which are used to render text in a visible way. A font provides the
Thread (java.lang)
A thread is a thread of execution in a program. The Java Virtual Machine allows an application to ha
Permission (java.security)
Legacy security code; do not use.
Arrays (java.util)
This class contains various methods for manipulating arrays (such as sorting and searching). This cl
Timer (java.util)
Timers schedule one-shot or recurring TimerTask for execution. Prefer java.util.concurrent.Scheduled
BasicDataSource (org.apache.commons.dbcp)
Basic implementation of javax.sql.DataSource that is configured via JavaBeans properties. This is no
Top plugins for WebStorm

How to use jodd.db.jtx.DbJtxSessionProviderconstructor

Best Java code snippets using jodd.db.jtx.DbJtxSessionProvider.<init> (Showing top 16 results out of 315)

How to use
jodd.db.jtx.DbJtxSessionProvider
constructor