DbTransationTest.java :  » Development » jodd » jodd » db » Java Open Source

// Copyright (c) 2003-2007, Jodd Team (jodd.sf.net). All Rights Reserved.

package jodd.db;

import junit.framework.TestCase;
import jodd.db.pool.CoreConnectionPool;
import jodd.db.jtx.DbJtxResourceManager;
import jodd.db.jtx.DbJtxTransactionManager;
import jodd.jtx.JtxTransactionManager;
import jodd.jtx.JtxTransaction;
import jodd.jtx.JtxTransactionMode;

import java.sql.ResultSet;
import java.sql.SQLException;

public class DbTransationTest extends TestCase {

  DbJtxTransactionManager tm;
  CoreConnectionPool pool;

  @Override
  protected void setUp() throws Exception {
    super.setUp();
    //noinspection NonConstantStringShouldBeStringBuffer
    String dbFile = System.getProperty("prj.build.dir");
    if (dbFile == null) {
      dbFile = "";
    }
    dbFile += "/db/jodd-db";
    pool = new CoreConnectionPool();
    pool.setDriver("org.hsqldb.jdbcDriver");
    pool.setUrl("jdbc:hsqldb:" + dbFile);
    pool.setUser("sa");
    pool.setPassword("");
    pool.init();
    tm = new DbJtxTransactionManager();
    tm.createDbResourceManager(pool);
  }


  @Override
  protected void tearDown() throws Exception {
    super.tearDown();
    tm.close();
  }


  // ---------------------------------------------------------------- misc

  public void testIsolation() throws SQLException {

    JtxTransactionManager manager = new JtxTransactionManager();
    manager.registerResourceManager(new DbJtxResourceManager(pool, "db"));

    JtxTransaction tx1 = manager.requestTransaction(new JtxTransactionMode().propagationRequired().setReadOnly(false));
    DbSession session1 = (DbSession) tx1.getResource("db");
    assertNotNull(session1);
    JtxTransaction tx2 = manager.requestTransaction(new JtxTransactionMode().propagationNotSupported());
    DbSession session2 = (DbSession) tx2.getResource("db");
    assertNotNull(session2);

    assertNotSame(session1, session2);
    assertEquals(2, manager.totalTransactions());
    assertEquals(1, manager.totalActiveTransactions());

    DbQuery query = new DbQuery(session1, "insert into GIRLS values(4, 'Jeniffer', 'fighting')");
    assertEquals(1, query.executeUpdate());
    query.close();

    DbQuery query2 = new DbQuery(session2, "select count(*) from GIRLS");
    ResultSet rs = query2.execute();
    if (rs.next()) {
      assertEquals(4, rs.getInt(1));
    }

    session1.rollbackTransaction();

    rs = query2.execute();
    if (rs.next()) {
      assertEquals(3, rs.getInt(1));
    }
    rs.close();

    //tx2.commit();
    //tx1.commit();
    manager.commitAll();
    assertEquals(0, manager.totalTransactions());
  }

  // ---------------------------------------------------------------- presentation layer

  public void testAction() {
    assertNotNull(tm);
    service0();
    JtxTransaction tx1 = service1();
    service2(tx1);
    service3(tx1);
    tm.commitAll();
    assertEquals(0, tm.totalActiveTransactions());
    assertEquals(0, tm.totalTransactions());
  }


  // ---------------------------------------------------------------- service layer


  DbSession s0;

  void service0() {
    assertFalse(tm.isUnderTransaction());
    assertEquals(0, tm.totalTransactions());
    JtxTransaction tx = tm.createTransaction(new JtxTransactionMode());
    assertTrue(tm.isUnderTransaction());
    assertFalse(tm.isUnderActiveTransaction());
    assertEquals(1, tm.totalTransactions());
    tx.begin();
    assertTrue(tm.isUnderActiveTransaction());
    s0 = anyDao();
    service0_1(tx);
    assertTrue(tm.isUnderActiveTransaction());
    assertTrue(tm.isUnderTransaction());
    tx.commit();
    assertFalse(tm.isUnderActiveTransaction());
    assertFalse(tm.isUnderTransaction());
    assertEquals(0, tm.totalTransactions());
  }

  void service0_1(JtxTransaction uptx) {
    assertTrue(tm.isUnderTransaction());
    assertTrue(tm.isUnderActiveTransaction());
    JtxTransaction tx = tm.getTransaction();
    assertTrue(tm.isUnderActiveTransaction());
    assertTrue(tm.isUnderTransaction());
    assertEquals(1, tm.totalTransactions());
    assertEquals(uptx, tx);
    assertEquals(s0, anyDao());
  }

  // ---------------------------------------------------------------- service layer

  DbSession s1;

  // service #1 REQUIRED
  JtxTransaction service1() {
    assertFalse(tm.isUnderTransaction());
    JtxTransaction tx = tm.requestTransaction(new JtxTransactionMode().propagationRequired());
    assertTrue(tm.isUnderTransaction());
    assertTrue(tm.isUnderActiveTransaction());
    assertEquals(1, tm.totalActiveTransactions());
    assertEquals(1, tm.totalTransactions());
    s1 = anyDao();
    return tx;
  }

  // service #2 REQUIRES NEW
  void service2(JtxTransaction tx1) {
    assertTrue(tm.isUnderTransaction());
    assertTrue(tm.isUnderActiveTransaction());
    JtxTransaction tx = tm.requestTransaction(new JtxTransactionMode().propagationRequiresNew());
    assertTrue(tm.isUnderTransaction());
    assertTrue(tm.isUnderActiveTransaction());
    assertEquals(2, tm.totalActiveTransactions());
    assertEquals(2, tm.totalTransactions());
    assertNotSame(tx1, tx);
    assertNotSame(s1, anyDao());
    assertTrue(tm.isUnderTransaction());
    assertTrue(tm.isUnderActiveTransaction());
    tx.commit();
    assertTrue(tm.isUnderTransaction());
    assertTrue(tm.isUnderActiveTransaction());
  }

  // service #3 REQUIRED
  void service3(JtxTransaction tx1) {
    assertTrue(tm.isUnderTransaction());
    assertTrue(tm.isUnderActiveTransaction());
    JtxTransaction tx = tm.requestTransaction(new JtxTransactionMode().propagationRequired());
    assertTrue(tm.isUnderTransaction());
    assertTrue(tm.isUnderActiveTransaction());
    assertEquals(tx1, tx);
    assertEquals(1, tm.totalActiveTransactions());
    assertEquals(1, tm.totalTransactions());
    assertEquals(s1, anyDao());
    service3_1(tx);
    assertEquals(s1, anyDao());
    assertTrue(tm.isUnderTransaction());
    assertTrue(tm.isUnderActiveTransaction());
  }

  // service #3_1 NOT SUPPORTED
  void service3_1(JtxTransaction tx3) {
    assertTrue(tm.isUnderTransaction());
    assertTrue(tm.isUnderActiveTransaction());
    JtxTransaction tx = tm.requestTransaction(new JtxTransactionMode().propagationNotSupported());
    assertTrue(tm.isUnderTransaction());
    assertFalse(tm.isUnderActiveTransaction());
    assertNotSame(tx3, tx);
    assertEquals(1, tm.totalActiveTransactions());
    assertEquals(2, tm.totalTransactions());
    assertNotSame(s1, anyDao());
    assertNotSame(s1, anyDao());
    assertTrue(tm.isUnderTransaction());
    assertFalse(tm.isUnderActiveTransaction());
    tx.commit();
    assertTrue(tm.isUnderTransaction());
    assertTrue(tm.isUnderActiveTransaction());
  }

  // ---------------------------------------------------------------- dao layer

  DbSession anyDao() {
    DbSession session1 = tm.getDbSession();
    DbSession session2 = (DbSession) tm.getResource(DbJtxResourceManager.DEFAULT_RESOURCE_TYPE);
    assertEquals(session1, session2);
    return session1;
  }


}