Package jodd.db

Source Code of jodd.db.DbTransactionTest

// Copyright (c) 2003-2014, Jodd Team (jodd.org). All Rights Reserved.

package jodd.db;

import jodd.db.jtx.DbJtxResourceManager;
import jodd.db.jtx.DbJtxTransaction;
import jodd.jtx.JtxException;
import jodd.jtx.JtxTransaction;
import jodd.jtx.JtxTransactionManager;
import jodd.jtx.JtxTransactionMode;
import jodd.util.ThreadUtil;
import org.junit.Test;

import java.sql.SQLException;

import static org.junit.Assert.*;

public class DbTransactionTest extends DbHsqldbTestCase {

  /**
   * Tests if rollback works.
   */
  @Test
  public void testRollback() throws SQLException {
    // prepare manager
    JtxTransactionManager manager = new JtxTransactionManager();
    manager.registerResourceManager(new DbJtxResourceManager(cp));

    // request transaction
    JtxTransaction tx = manager.requestTransaction(new JtxTransactionMode().propagationRequired().readOnly(false));
    DbSession session = tx.requestResource(DbSession.class);
    assertNotNull(session);

    // insert two records
    DbQuery query = new DbQuery(session, "insert into GIRL values(4, 'Jeniffer', 'fighting')");
    assertEquals(1, query.executeUpdate());
    query = new DbQuery(session, "insert into GIRL values(5, 'Annita', 'bartender')");
    assertEquals(1, query.executeUpdate());

    // rollback
    tx.rollback();

    // check !!!
    session = new DbSession(cp);

    DbQuery query2 = new DbQuery(session, "select count(*) from GIRL");
    long count = query2.executeCount();

    assertEquals(0, count);
    session.closeSession();
  }


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

/*
  public void testIsolation() throws SQLException {
    JtxTransactionManager manager = new JtxTransactionManager();
    manager.registerResourceManager(new DbJtxResourceManager(cp));

    JtxTransaction tx1 = manager.requestTransaction(new JtxTransactionMode().propagationRequired().readOnly(false));
    DbSession session1 = tx1.requestResource(DbSession.class);
    assertNotNull(session1);
    JtxTransaction tx2 = manager.requestTransaction(new JtxTransactionMode().propagationNotSupported());
    DbSession session2 = tx2.requestResource(DbSession.class);
    assertNotNull(session2);

    assertNotSame(session1, session2);
    assertTotals(manager, 2, 1);

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

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

    session1.rollbackTransaction();

    rs = query2.execute();
    if (rs.next()) {
      assertEquals(0, rs.getInt(1));
    }
    rs.close();
   
    tx2.commit();
    tx1.commit();
   
    assertTotals(manager, 0, 0);
  }
*/

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


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


  DbSession s0;

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

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

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

  DbSession s1;

  // service #1 REQUIRED
  JtxTransaction service1() {
    assertTotals(0, 0);
    DbJtxTransaction tx = dbtxm.requestTransaction(new JtxTransactionMode().propagationRequired());
    assertTotals(1, 1);
    s1 = tx.requestResource();
    return tx;
  }

  // service #2 REQUIRES NEW
  void service2(JtxTransaction tx1) {
    assertTotals(1, 1);
    DbJtxTransaction tx = dbtxm.requestTransaction(new JtxTransactionMode().propagationRequiresNew());
    assertTotals(2, 2);
    assertNotSame(tx1, tx);
    assertNotSame(s1, tx.requestResource());
    tx.commit();
    assertTotals(1, 1);
  }

  // service #3 REQUIRED
  void service3(JtxTransaction tx1) {
    assertTotals(1, 1);
    DbJtxTransaction tx = dbtxm.requestTransaction(new JtxTransactionMode().propagationRequired());
    assertEquals(tx1, tx);
    assertTotals(1, 1);
    assertEquals(s1, tx.requestResource());
    service3_1(tx);
    assertEquals(s1, tx.requestResource());
    assertTotals(1, 1);
  }

  // service #3_1 NOT SUPPORTED
  void service3_1(JtxTransaction tx3) {
    assertTotals(1, 1);
    DbJtxTransaction tx = dbtxm.requestTransaction(new JtxTransactionMode().propagationNotSupported());
    assertNotSame(tx3, tx);
    assertTotals(2, 1);
    assertNotSame(s1, tx.requestResource());
    assertNotSame(s1, tx.requestResource());
    tx.commit();
    assertTotals(1, 1);
  }


  // ---------------------------------------------------------------- util

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

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

  // ---------------------------------------------------------------- test time
  @Test
  public void testTime() {
    JtxTransactionManager manager = new JtxTransactionManager();
    manager.registerResourceManager(new DbJtxResourceManager(cp));

    JtxTransaction tx1 = manager.requestTransaction(new JtxTransactionMode().propagationRequired().transactionTimeout(1));
    DbSession session1 = tx1.requestResource(DbSession.class);
    assertNotNull(session1);
    executeCount(session1, "select count(*) from GIRL");

    ThreadUtil.sleep(2000);
    try {
      DbSession session2 = tx1.requestResource(DbSession.class);
      assertNotNull(session2);
      assertSame(session1, session2);
      executeCount(session1, "select count(*) from GIRL");
      fail();
    } catch (JtxException ignore) {

    }
    tx1.rollback();
  }


  // ---------------------------------------------------------------- thread
  @Test
  public void testThread() {
    final JtxTransactionManager manager = new JtxTransactionManager();
    manager.registerResourceManager(new DbJtxResourceManager(cp));
    final int[] count = new int[1];

    new Thread() {
      @Override
      public void run() {
        JtxTransaction tx = manager.requestTransaction(new JtxTransactionMode().propagationRequired().transactionTimeout(1));
        count[0]++;
        assertEquals(count[0], manager.totalTransactions());
        assertEquals(1, manager.totalTransactions());
        assertEquals(1, manager.totalThreadTransactions());
        ThreadUtil.sleep(1000);
        tx.commit();
        count[0]--;
      }
    }.start();
    ThreadUtil.sleep(500);
    new Thread() {
      @Override
      public void run() {
        JtxTransaction tx = manager.requestTransaction(new JtxTransactionMode().propagationRequired().transactionTimeout(1));
        count[0]++;
        assertEquals(count[0], manager.totalTransactions());
        assertEquals(2, manager.totalTransactions());
        assertEquals(1, manager.totalThreadTransactions());
        ThreadUtil.sleep(1000);
        tx.commit();
        count[0]--;
      }
    }.start();
  }

  // ---------------------------------------------------------------- notx
  @Test
  public void testNoTx() {

    final JtxTransactionManager manager = new JtxTransactionManager();
    manager.registerResourceManager(new DbJtxResourceManager(cp));

    JtxTransaction tx = manager.requestTransaction(new JtxTransactionMode().propagationSupports());
    assertTrue(tx.isNoTransaction());

    try {
      tx.commit();
    } catch (Exception ignore) {
      fail();
    }

    assertTrue(tx.isCommitted());

    try {
      tx.rollback();
      fail("exception is already committed!");
    } catch (Exception ignore) {
    }

    tx = manager.requestTransaction(new JtxTransactionMode().propagationSupports());

    try {
      tx.rollback();
    } catch (Exception ex) {
      fail(ex.toString());
    }

    tx = manager.requestTransaction(new JtxTransactionMode().propagationSupports());

    try {
      tx.setRollbackOnly();
    } catch (Exception ex) {
      fail(ex.toString());
    }
  }
}
TOP

Related Classes of jodd.db.DbTransactionTest

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.