public void testPoolReset() throws Exception {
    if (log.isDebugEnabled()) {
      log.debug("*** Starting testPoolReset");
    }

    Field poolField = pds.getClass().getDeclaredField("pool");
    poolField.setAccessible(true);
    XAPool pool = (XAPool) poolField.get(pds);

    assertEquals(1, pool.inPoolSize());
    assertEquals(1, pool.totalPoolSize());

    Connection c1 = pds.getConnection();
    assertEquals(0, pool.inPoolSize());
    assertEquals(1, pool.totalPoolSize());

    Connection c2 = pds.getConnection();
    assertEquals(0, pool.inPoolSize());
    assertEquals(2, pool.totalPoolSize());

    c1.close();
    c2.close();

    pds.reset();

    assertEquals(1, pool.inPoolSize());
    assertEquals(1, pool.totalPoolSize());
  }
  public void testPoolShrink() throws Exception {
    if (log.isDebugEnabled()) {
      log.debug("*** Starting testPoolShrink");
    }
    Field poolField = pds.getClass().getDeclaredField("pool");
    poolField.setAccessible(true);
    XAPool pool = (XAPool) poolField.get(pds);

    assertEquals(1, pool.inPoolSize());
    assertEquals(1, pool.totalPoolSize());

    Connection c1 = pds.getConnection();
    assertEquals(0, pool.inPoolSize());
    assertEquals(1, pool.totalPoolSize());

    Connection c2 = pds.getConnection();
    assertEquals(0, pool.inPoolSize());
    assertEquals(2, pool.totalPoolSize());

    c1.close();
    c2.close();

    Thread.sleep(1100); // leave enough time for the idle connections to expire
    TransactionManagerServices.getTaskScheduler().interrupt(); // wake up the task scheduler
    Thread.sleep(1200); // leave enough time for the scheduled shrinking task to do its work

    if (log.isDebugEnabled()) {
      log.debug("*** checking pool sizes");
    }
    assertEquals(1, pool.inPoolSize());
    assertEquals(1, pool.totalPoolSize());
  }
  public void testPoolGrowth() throws Exception {
    if (log.isDebugEnabled()) {
      log.debug("*** Starting testPoolGrowth");
    }
    Field poolField = pds.getClass().getDeclaredField("pool");
    poolField.setAccessible(true);
    XAPool pool = (XAPool) poolField.get(pds);

    assertEquals(1, pool.inPoolSize());
    assertEquals(1, pool.totalPoolSize());

    Connection c1 = pds.getConnection();
    assertEquals(0, pool.inPoolSize());
    assertEquals(1, pool.totalPoolSize());

    Connection c2 = pds.getConnection();
    assertEquals(0, pool.inPoolSize());
    assertEquals(2, pool.totalPoolSize());

    try {
      pds.getConnection();
      fail("should not be able to get a 3rd connection");
    } catch (SQLException ex) {
      assertEquals(
          "unable to get a connection from pool of a PoolingDataSource containing an XAPool of resource pds with 2 connection(s) (0 still available)",
          ex.getMessage());
    }

    c1.close();
    c2.close();
    assertEquals(2, pool.inPoolSize());
    assertEquals(2, pool.totalPoolSize());
  }
Exemple #4
0
  /**
   * This method should be called in the @After method of a test to clean up the persistence unit
   * and datasource.
   *
   * @param context A HashMap generated by {@link org.drools.persistence.util.PersistenceUtil
   *     setupWithPoolingDataSource(String)}
   */
  public static void cleanUp(HashMap<String, Object> context) {
    if (context != null) {

      BitronixTransactionManager txm = TransactionManagerServices.getTransactionManager();
      if (txm != null) {
        txm.shutdown();
      }

      Object emfObject = context.remove(ENTITY_MANAGER_FACTORY);
      if (emfObject != null) {
        try {
          EntityManagerFactory emf = (EntityManagerFactory) emfObject;
          emf.close();
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }

      Object ds1Object = context.remove(DATASOURCE);
      if (ds1Object != null) {
        try {
          PoolingDataSource ds1 = (PoolingDataSource) ds1Object;
          ds1.close();
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }
    }
  }
  public void testPoolShrinkErrorHandling() throws Exception {
    if (log.isDebugEnabled()) {
      log.debug("*** Starting testPoolShrinkErrorHandling");
    }

    Field poolField = pds.getClass().getDeclaredField("pool");
    poolField.setAccessible(true);
    XAPool pool = (XAPool) poolField.get(pds);

    pds.setMinPoolSize(0);
    pds.reset();
    pds.setMinPoolSize(1);
    MockitoXADataSource.setStaticCloseXAConnectionException(
        new SQLException("close fails because datasource broken"));
    pds.reset();

    // the pool is now loaded with one connection which will throw an exception when closed
    Thread.sleep(1100); // leave enough time for the ide connections to expire
    TransactionManagerServices.getTaskScheduler().interrupt(); // wake up the task scheduler
    Thread.sleep(100); // leave enough time for the scheduled shrinking task to do its work
    assertEquals(1, pool.inPoolSize());

    MockitoXADataSource.setStaticGetXAConnectionException(
        new SQLException("getXAConnection fails because datasource broken"));
    Thread.sleep(1100); // leave enough time for the ide connections to expire
    TransactionManagerServices.getTaskScheduler().interrupt(); // wake up the task scheduler
    Thread.sleep(100); // leave enough time for the scheduled shrinking task to do its work
    assertEquals(0, pool.inPoolSize());

    MockitoXADataSource.setStaticGetXAConnectionException(null);
    Thread.sleep(1100); // leave enough time for the ide connections to expire
    TransactionManagerServices.getTaskScheduler().interrupt(); // wake up the task scheduler
    Thread.sleep(100); // leave enough time for the scheduled shrinking task to do its work
    assertEquals(1, pool.inPoolSize());
  }
Exemple #6
0
  /**
   * This method does all of the setup for the test and returns a HashMap containing the persistence
   * objects that the test might need.
   *
   * @param persistenceUnitName The name of the persistence unit used by the test.
   * @return HashMap<String Object> with persistence objects, such as the EntityManagerFactory and
   *     DataSource
   */
  public static HashMap<String, Object> setupWithPoolingDataSource(
      final String persistenceUnitName, String dataSourceName, final boolean testMarshalling) {
    HashMap<String, Object> context = new HashMap<String, Object>();

    // set the right jdbc url
    Properties dsProps = getDatasourceProperties();
    String jdbcUrl = dsProps.getProperty("url");
    String driverClass = dsProps.getProperty("driverClassName");

    determineTestMarshalling(dsProps, testMarshalling);

    if (TEST_MARSHALLING) {
      Class<?> testClass = null;
      StackTraceElement[] ste = Thread.currentThread().getStackTrace();
      int i = 1;
      do {
        try {
          testClass = Class.forName(ste[i++].getClassName());
        } catch (ClassNotFoundException e) {
          // do nothing..
        }
      } while (PersistenceUtil.class.equals(testClass) && i < ste.length);
      assertNotNull("Unable to resolve test class!", testClass);

      jdbcUrl = initializeTestDb(dsProps, testClass);
    }

    boolean startH2TcpServer = false;
    if (jdbcUrl.matches("jdbc:h2:tcp:.*")) {
      startH2TcpServer = true;
    }

    // Setup the datasource
    PoolingDataSource ds1 = setupPoolingDataSource(dsProps, dataSourceName, startH2TcpServer);
    if (driverClass.startsWith("org.h2")) {
      ds1.getDriverProperties().setProperty("url", jdbcUrl);
    }
    ds1.init();
    context.put(DATASOURCE, ds1);

    // Setup persistence
    EntityManagerFactory emf;
    if (TEST_MARSHALLING) {
      Properties overrideProperties = new Properties();
      overrideProperties.setProperty("hibernate.connection.url", jdbcUrl);
      EntityManagerFactory realEmf =
          Persistence.createEntityManagerFactory(persistenceUnitName, overrideProperties);
      emf = (EntityManagerFactory) EntityManagerFactoryProxy.newInstance(realEmf);

      UserTransaction ut = (UserTransaction) UserTransactionProxy.newInstance(realEmf);
      context.put(TRANSACTION, ut);
    } else {
      emf = Persistence.createEntityManagerFactory(persistenceUnitName);
    }

    context.put(ENTITY_MANAGER_FACTORY, emf);

    return context;
  }
  public void testDelistErrorAndUnilateralRollbackOnCommit() throws Exception {
    btm.begin();

    Connection connection1 = poolingDataSource1.getConnection();
    JdbcConnectionHandle handle1 = (JdbcConnectionHandle) Proxy.getInvocationHandler(connection1);
    XAConnection xaConnection1 =
        (XAConnection) AbstractMockJdbcTest.getWrappedXAConnectionOf(handle1.getPooledConnection());
    MockXAResource xaResource1 = (MockXAResource) xaConnection1.getXAResource();
    xaResource1.setEndException(
        new BitronixXAException("screw delistment", XAException.XAER_RMERR));
    xaResource1.setRollbackException(
        new BitronixXAException("delistment was screwed, cannot rollback", XAException.XAER_RMERR));

    connection1.createStatement(); // triggers enlistment

    Connection connection2 = poolingDataSource2.getConnection();
    JdbcConnectionHandle handle2 = (JdbcConnectionHandle) Proxy.getInvocationHandler(connection2);
    XAConnection xaConnection2 =
        (XAConnection) AbstractMockJdbcTest.getWrappedXAConnectionOf(handle2.getPooledConnection());
    MockXAResource xaResource2 = (MockXAResource) xaConnection2.getXAResource();
    xaResource2.setEndException(
        new BitronixXAException("what was that transaction again?", XAException.XAER_NOTA));
    xaResource2.setRollbackException(
        new BitronixXAException(
            "delistment unilaterally rolled back, cannot rollback twice", XAException.XAER_RMERR));

    connection2.createStatement(); // triggers enlistment

    try {
      btm.commit();
      fail("expected RollbackException");
    } catch (RollbackException ex) {
      assertEquals(
          "delistment error caused transaction rollback"
              + System.getProperty("line.separator")
              + "  resource(s) [pds2] unilaterally rolled back"
              + System.getProperty("line.separator")
              + "  resource(s) [pds1] could not be delisted",
          ex.getMessage());
    }

    // check flow
    List orderedEvents = EventRecorder.getOrderedEvents();
    log.info(EventRecorder.dumpToString());

    assertEquals(8, orderedEvents.size());
    int i = 0;
    assertEquals(Status.STATUS_ACTIVE, ((JournalLogEvent) orderedEvents.get(i++)).getStatus());
    assertEquals(XAResource.TMNOFLAGS, ((XAResourceStartEvent) orderedEvents.get(i++)).getFlag());
    assertEquals(XAResource.TMNOFLAGS, ((XAResourceStartEvent) orderedEvents.get(i++)).getFlag());
    assertEquals(XAResource.TMSUCCESS, ((XAResourceEndEvent) orderedEvents.get(i++)).getFlag());
    assertEquals(
        Status.STATUS_MARKED_ROLLBACK, ((JournalLogEvent) orderedEvents.get(i++)).getStatus());
    assertEquals(XAResource.TMSUCCESS, ((XAResourceEndEvent) orderedEvents.get(i++)).getFlag());
    assertEquals(
        Status.STATUS_ROLLING_BACK, ((JournalLogEvent) orderedEvents.get(i++)).getStatus());
    assertEquals(Status.STATUS_ROLLEDBACK, ((JournalLogEvent) orderedEvents.get(i++)).getStatus());
  }
  public void testWrappers() throws Exception {
    if (log.isDebugEnabled()) {
      log.debug("*** Starting testWrappers");
    }
    try {
      Connection.class.getMethod("isWrapperFor");
    } catch (NoSuchMethodException e) {
      // if there is no such method this means the JVM is running with pre-JDBC4 classes
      // so this test becomes pointless and must be skipped
      return;
    }

    // XADataSource
    assertTrue(pds.isWrapperFor(XADataSource.class));
    assertFalse(pds.isWrapperFor(DataSource.class));
    XADataSource unwrappedXads = (XADataSource) pds.unwrap(XADataSource.class);
    assertEquals(MockitoXADataSource.class.getName(), unwrappedXads.getClass().getName());

    // Connection
    Connection c = pds.getConnection();
    assertTrue(isWrapperFor(c, Connection.class));
    Connection unwrappedConnection = (Connection) unwrap(c, Connection.class);
    assertTrue(
        unwrappedConnection.getClass().getName().contains("java.sql.Connection")
            && unwrappedConnection.getClass().getName().contains("EnhancerByMockito"));

    // Statement
    Statement stmt = c.createStatement();
    assertTrue(isWrapperFor(stmt, Statement.class));
    Statement unwrappedStmt = (Statement) unwrap(stmt, Statement.class);
    assertTrue(
        unwrappedStmt.getClass().getName().contains("java.sql.Statement")
            && unwrappedStmt.getClass().getName().contains("EnhancerByMockito"));

    // PreparedStatement
    PreparedStatement pstmt = c.prepareStatement("mock sql");
    assertTrue(isWrapperFor(pstmt, PreparedStatement.class));
    Statement unwrappedPStmt = (Statement) unwrap(pstmt, PreparedStatement.class);
    assertTrue(
        unwrappedPStmt.getClass().getName().contains("java.sql.PreparedStatement")
            && unwrappedPStmt.getClass().getName().contains("EnhancerByMockito"));

    // CallableStatement
    CallableStatement cstmt = c.prepareCall("mock stored proc");
    assertTrue(isWrapperFor(cstmt, CallableStatement.class));
    Statement unwrappedCStmt = (Statement) unwrap(cstmt, CallableStatement.class);
    assertTrue(
        unwrappedCStmt.getClass().getName().contains("java.sql.CallableStatement")
            && unwrappedCStmt.getClass().getName().contains("EnhancerByMockito"));
  }
  public void testPoolResetErrorHandling() throws Exception {
    if (log.isDebugEnabled()) {
      log.debug("*** Starting testPoolResetErrorHandling");
    }
    Field poolField = pds.getClass().getDeclaredField("pool");
    poolField.setAccessible(true);
    XAPool pool = (XAPool) poolField.get(pds);

    pds.setMinPoolSize(0);
    pds.reset();
    pds.setMinPoolSize(1);
    MockitoXADataSource.setStaticCloseXAConnectionException(
        new SQLException("close fails because datasource broken"));
    pds.reset();

    // the pool is now loaded with one connection which will throw an exception when closed
    pds.reset();

    try {
      MockitoXADataSource.setStaticGetXAConnectionException(
          new SQLException("getXAConnection fails because datasource broken"));
      pds.reset();
      fail("expected SQLException");
    } catch (SQLException ex) {
      assertEquals("getXAConnection fails because datasource broken", ex.getMessage());
      assertEquals(0, pool.inPoolSize());
    }

    MockitoXADataSource.setStaticGetXAConnectionException(null);
    pds.reset();
    assertEquals(1, pool.inPoolSize());
  }
  public void testCloseGlobalContextRecycle() throws Exception {
    if (log.isDebugEnabled()) {
      log.debug("*** Starting testCloseGlobalContextRecycle");
    }
    TransactionManager tm = TransactionManagerServices.getTransactionManager();
    tm.begin();

    Connection c1 = pds.getConnection();
    c1.createStatement();
    c1.close();
    assertTrue(c1.isClosed());

    try {
      c1.createStatement();
      fail("expected SQLException");
    } catch (SQLException ex) {
      assertEquals("connection handle already closed", ex.getMessage());
    }

    Connection c2 = pds.getConnection();
    c2.createStatement();

    try {
      c2.commit();
      fail("expected SQLException");
    } catch (SQLException ex) {
      assertEquals("cannot commit a resource enlisted in a global transaction", ex.getMessage());
    }

    tm.commit();
    assertFalse(c2.isClosed());

    c2.close();
    assertTrue(c2.isClosed());

    try {
      c2.createStatement();
      fail("expected SQLException");
    } catch (SQLException ex) {
      assertEquals("connection handle already closed", ex.getMessage());
    }

    try {
      c2.commit();
      fail("expected SQLException");
    } catch (SQLException ex) {
      assertEquals("connection handle already closed", ex.getMessage());
    }
  }
  @After
  public void tearDown() throws Exception {
    int removeAllTasks = taskService.removeAllTasks();

    emf.close();
    ds.close();
  }
 @After
 public void teardown() {
   if (manager != null) {
     manager.close();
   }
   pds.close();
 }
 protected void onTearDown() throws Exception {
   taskSession.dispose();
   emfTaskJPA.close();
   if (useJTA) {
     ds.close();
   }
 }
  @Override
  protected void setUp() throws Exception {
    ds1 = setupPoolingDataSource();
    ds1.init();

    emf = Persistence.createEntityManagerFactory(PERSISTENCE_UNIT_NAME);
  }
 @Before
 public void setUp() throws Exception {
   ds = setupPoolingDataSource();
   logger.debug("Data source configured with unique id {}", ds.getUniqueName());
   emf = Persistence.createEntityManagerFactory(PERSISTENCE_UNIT_NAME);
   cleanupSingletonSessionId();
 }
  protected void prepareDb() {
    try {
      Connection conn = pds.getConnection();
      String createUserTableSql = "create table Users (userId varchar(255))";
      PreparedStatement st = conn.prepareStatement(createUserTableSql);
      st.execute();

      String createGroupTableSql =
          "create table Groups (groupId varchar(255), userId varchar(255))";
      st = conn.prepareStatement(createGroupTableSql);
      st.execute();

      // insert user rows
      String insertUser = "******";
      st = conn.prepareStatement(insertUser);
      st.setString(1, "john");
      st.execute();

      // insert group rows
      String insertGroup = "insert into Groups (groupId, userId) values (?, ?)";
      st = conn.prepareStatement(insertGroup);
      st.setString(1, "PM");
      st.setString(2, "john");
      st.execute();

      st.close();
      conn.close();

    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  @Before
  public void setUp() {
    ds1 = new PoolingDataSource();
    ds1.setClassName("bitronix.tm.resource.jdbc.lrc.LrcXADataSource");
    ds1.setUniqueName("jdbc/testDS1");
    ds1.setMaxPoolSize(5);
    ds1.setAllowLocalTransactions(true);
    ds1.getDriverProperties().setProperty("driverClassName", "org.h2.Driver");
    ds1.getDriverProperties().setProperty("url", "jdbc:h2:tcp://localhost/JPADroolsFlow");
    ds1.getDriverProperties().setProperty("user", "sa");
    ds1.getDriverProperties().setProperty("password", "");

    // ds1.setUniqueName( "jdbc/testDS1" );
    // ds1.setClassName( "org.h2.Driver" );
    // ds1.setMaxPoolSize( 3 );
    // ds1.setAllowLocalTransactions( true );
    // ds1.getDriverProperties().put( "user",
    // "sa" );
    // ds1.getDriverProperties().put( "password",
    // "" );
    // ds1.getDriverProperties().put( "URL",
    // "jdbc:h2:tcp://localhost/JPADroolsFlow" );
    ds1.init();

    emf = Persistence.createEntityManagerFactory("org.drools.persistence.jpa");
  }
 @After
 public void tearDown() throws Exception {
   try {
     emf.close();
     ds1.close();
   } catch (Exception e) {
     e.printStackTrace();
   }
 }
Exemple #19
0
 protected void tearDown() throws Exception {
   if (taskSession != null) {
     taskSession.dispose();
   }
   emf.close();
   if (useJTA) {
     pds.close();
   }
 }
  public void testReEnteringRecovery() throws Exception {
    if (log.isDebugEnabled()) {
      log.debug("*** Starting testReEnteringRecovery");
    }
    pds.startRecovery();
    try {
      pds.startRecovery();
      fail("expected RecoveryException");
    } catch (RecoveryException ex) {
      assertEquals(
          "recovery already in progress on a PoolingDataSource containing an XAPool of resource pds with 1 connection(s) (0 still available)",
          ex.getMessage());
    }

    // make sure startRecovery() can be called again once endRecovery() has been called
    pds.endRecovery();
    pds.startRecovery();
    pds.endRecovery();
  }
  @Before
  public void setUp() throws Exception {

    if (setupDataSource) {
      ds = setupPoolingDataSource();
      logger.debug("Data source configured with unique id {}", ds.getUniqueName());
      emf = Persistence.createEntityManagerFactory(persistenceUnitName);
    }
    cleanupSingletonSessionId();
  }
 protected PoolingDataSource setupPoolingDataSource() {
   PoolingDataSource pds = new PoolingDataSource();
   pds.setUniqueName("jdbc/jbpm-ds");
   pds.setClassName("bitronix.tm.resource.jdbc.lrc.LrcXADataSource");
   pds.setMaxPoolSize(5);
   pds.setAllowLocalTransactions(true);
   pds.getDriverProperties().put("user", "sa");
   pds.getDriverProperties().put("password", "");
   pds.getDriverProperties().put("url", "jdbc:h2:mem:jbpm-db;MVCC=true");
   pds.getDriverProperties().put("driverClassName", "org.h2.Driver");
   pds.init();
   return pds;
 }
  @Before
  public void setup() {

    Properties dsProps = loadDataSourceProperties();

    pds = new PoolingDataSource();
    pds.setUniqueName("jdbc/jbpm-ds");
    pds.setClassName(dsProps.getProperty("className"));
    pds.setMaxPoolSize(Integer.parseInt(dsProps.getProperty("maxPoolSize")));
    pds.setAllowLocalTransactions(
        Boolean.parseBoolean(dsProps.getProperty("allowLocalTransactions")));
    for (String propertyName : new String[] {"user", "password"}) {
      pds.getDriverProperties().put(propertyName, dsProps.getProperty(propertyName));
    }
    setDatabaseSpecificDataSourceProperties(pds, dsProps);

    pds.init();

    prepareDb();

    props = new Properties();
    props.setProperty(DBUserGroupCallbackImpl.DS_JNDI_NAME, "jdbc/jbpm-ds");
    props.setProperty(
        DBUserGroupCallbackImpl.PRINCIPAL_QUERY, "select userId from Users where userId = ?");
    props.setProperty(
        DBUserGroupCallbackImpl.ROLES_QUERY, "select groupId from Groups where groupId = ?");
    props.setProperty(
        DBUserGroupCallbackImpl.USER_ROLES_QUERY, "select groupId from Groups where userId = ?");
  }
  public void testObjectProperties() throws Exception {
    pds.close();

    pds = new PoolingDataSource();
    pds.setUniqueName("pds");
    pds.setClassName(MockitoXADataSource.class.getName());
    pds.setMinPoolSize(1);
    pds.setMaxPoolSize(1);
    pds.getDriverProperties().put("uselessThing", new Object());
    pds.init();
  }
  private static void configureJdbcPool(
      Map<String, PoolingDataSource> dataSources, Set<ResourceBean> started, Configuration config)
      throws ConfigurationException {
    PoolingDataSource ds = new PoolingDataSource();
    final String uniqueName = confgureResourceBean(ds, config);

    for (Configuration child : config.getChildren()) {
      switch (child.getName()) {
        case "testQuery":
          ds.setTestQuery(child.getValue());
          break;
        case "enableJdbc4ConnectionTest":
          ds.setEnableJdbc4ConnectionTest(child.getValueAsBoolean());
          break;
        case "preparedStatementCacheSize":
          ds.setPreparedStatementCacheSize(child.getValueAsInteger());
          break;
        case "isolationLevel":
          ds.setIsolationLevel(child.getValue());
          break;
        case "cursorHoldability":
          ds.setCursorHoldability(child.getValue());
          break;
        case "localAutoCommit":
          ds.setLocalAutoCommit(child.getValue());
          break;
        case "driverProperties":
          configureDriverProperties(ds.getDriverProperties(), child);
          break;
        default:
          if (!RESOURCE_BEAN_PROPERTIES.contains(child.getName())) {
            throw new ConfigurationException(
                "unsupported element " + child.getName(), child.getPath(), child.getLocation());
          }
      }
    }

    if (config.getAttributeAsBoolean("eager", false)) {
      ds.init();
      started.add(ds);
    }
    dataSources.put(uniqueName, ds);
  }
  @After
  public void tearDown() throws Exception {
    clearHistory();
    disposeRuntimeManager();

    if (emf != null) {
      emf.close();
      emf = null;
    }
    if (ds != null) {
      ds.close();
      ds = null;
    }
  }
 @Before
 public void setUp() throws Exception {
   ds1 = new PoolingDataSource();
   ds1.setUniqueName("jdbc/testDS1");
   ds1.setClassName("org.h2.jdbcx.JdbcDataSource");
   ds1.setMaxPoolSize(3);
   ds1.setAllowLocalTransactions(true);
   ds1.getDriverProperties().put("user", "sa");
   ds1.getDriverProperties().put("password", "sasa");
   ds1.getDriverProperties().put("URL", "jdbc:h2:mem:mydb");
   ds1.init();
   emf = Persistence.createEntityManagerFactory("org.drools.persistence.jpa");
 }
  protected void setUp() throws Exception {
    TransactionManagerServices.getConfiguration().setJournal("null").setGracefulShutdownInterval(2);
    TransactionManagerServices.getTransactionManager();

    MockitoXADataSource.setStaticCloseXAConnectionException(null);
    MockitoXADataSource.setStaticGetXAConnectionException(null);

    pds = new PoolingDataSource();
    pds.setMinPoolSize(1);
    pds.setMaxPoolSize(2);
    pds.setMaxIdleTime(1);
    pds.setClassName(MockitoXADataSource.class.getName());
    pds.setUniqueName("pds");
    pds.setAllowLocalTransactions(true);
    pds.setAcquisitionTimeout(1);
    pds.init();
  }
Exemple #29
0
 public static PoolingDataSource setupDataSource() {
   Properties properties = getProperties();
   // create data source
   PoolingDataSource pds = new PoolingDataSource();
   pds.setUniqueName(properties.getProperty("persistence.datasource.name", "jdbc/jbpm-ds"));
   pds.setClassName("bitronix.tm.resource.jdbc.lrc.LrcXADataSource");
   pds.setMaxPoolSize(5);
   pds.setAllowLocalTransactions(true);
   pds.getDriverProperties()
       .put("user", properties.getProperty("persistence.datasource.user", "sa"));
   pds.getDriverProperties()
       .put("password", properties.getProperty("persistence.datasource.password", ""));
   pds.getDriverProperties()
       .put(
           "url",
           properties.getProperty(
               "persistence.datasource.url", "jdbc:h2:tcp://localhost/~/jbpm-db;MVCC=TRUE"));
   pds.getDriverProperties()
       .put(
           "driverClassName",
           properties.getProperty("persistence.datasource.driverClassName", "org.h2.Driver"));
   pds.init();
   return pds;
 }
  private void setupDataSource() {
    if (null != pds) return;

    pds = new PoolingDataSource();
    pds.setUniqueName("java:/accounts-ds");
    pds.setClassName("bitronix.tm.resource.jdbc.lrc.LrcXADataSource");
    pds.setMaxPoolSize(5);
    pds.setAllowLocalTransactions(true);
    pds.getDriverProperties().put("user", "sa");
    pds.getDriverProperties().put("password", "sa");
    pds.getDriverProperties().put("url", "jdbc:h2:mem://localhost/~/test");
    pds.getDriverProperties().put("driverClassName", "org.h2.Driver");
    pds.init();
  }