/** * Verifies the MessageDrivenContext methods. * * @param msg message */ public void onMessage(final Message msg) { String op = null; try { op = msg.getStringProperty(MessageProperty.OPERATION.toString()); } catch (JMSException e) { logger.debug("Error getting operation type: {0}", e); } if (ctx == null) { logger.debug("The SessionContext reference is null."); } else if (isEqual(GET_CALLER_PRINCIPAL, op)) { // TODO: test case } else if (isEqual(GET_ROLLBACK_ONLY, op)) { try { ctx.getRollbackOnly(); } catch (IllegalStateException e) { log( MDBBeanManagedContext.class, ON_MESSAGE, MDBBeanManagedContext.class, GET_ROLLBACK_ONLY); } catch (Exception e) { logger.debug("Unexpected error.", e); } } else if (isEqual(SET_ROLLBACK_ONLY, op)) { try { ctx.setRollbackOnly(); } catch (IllegalStateException e) { log( MDBBeanManagedContext.class, ON_MESSAGE, MDBBeanManagedContext.class, SET_ROLLBACK_ONLY); } } else if (isEqual(TIMER, op)) { try { checkInstance(ctx.getTimerService()); log(MDBBeanManagedContext.class, ON_MESSAGE, MDBBeanManagedContext.class, TIMER); } catch (Exception e) { logger.debug("Unexpected error.", e); } } else if (isEqual(USER_TRANSACTION, op)) { try { checkInstance(ctx.getTimerService()); log(MDBBeanManagedContext.class, ON_MESSAGE, MDBBeanManagedContext.class, USER_TRANSACTION); } catch (Exception e) { logger.debug("Unexpected error.", e); } } }
/** * Verifies if the container re-throws the application exception that extends a runtime exception * (with rollback = false) and does not do the rollback in this case. The test uses a client * transaction. * * @throws Exception if an error during the tests occurs. */ public void testUsingClientTransWithAppRuntimeException() throws Exception { UserTransaction utx = ExceptionHandleUtil.getUserTransaction(); utx.begin(); try { sfsbContainerTransactionApp01.insertCorrectFirstErrorSecond(DATABASE_1, DATABASE_2); fail("The container did not re-throw the application exception."); } catch (AppRuntimeException e) { logger.debug("The bean threw an expected error during the execution {0}", e); } // tries to commit try { utx.commit(); } catch (Exception e) { logger.debug("The bean threw an expected error during the execution {0}", e); } // verifies if the table was created in the DATABASE_1 ExceptionHandleUtil.verifyTable(DATABASE_1, ItfContainerTransaction.TABLE); }
/** * Verifies if the container re-throws the application exception that extends a runtime exception * (with rollback = true) and marks the transaction for rollback in this case. * * @throws Exception if an error during the tests occurs. */ public void testNotUsingClientTransWithAppRuntimeRollbackException() throws Exception { try { sfsbContainerTransactionApp02.insertCorrectFirstErrorSecond(DATABASE_1, DATABASE_2); fail("The container did not re-throw the application exception."); } catch (RollbackAppRuntimeException e) { logger.debug("The bean threw an expected error during the execution {0}", e); } // verifies if the table was created in the DATABASE_1 ExceptionHandleUtil.verifyTable(DATABASE_1, ItfContainerTransaction.TABLE); }
/** * Verifies if the container throws the correct exception (EJBException for RequiresNew and * NotSupports, and EJBTransactionRolledbackException for Require, Supports and Mandatory) when * the bean throws a RuntimeException, discards the bean and does the rollback if the bean uses * the client transaction. * * @param expectedException EJBException for RequiresNew and NotSupports, and * EJBTransactionRolledbackException for Require, Supports and Mandatory * @param canCommit true if the bean does not use the client transaction. * @throws Exception if an error during the tests occurs. */ public void testUsingClientTransWithRuntimeException( final Class expectedException, final boolean canCommit) throws Exception { UserTransaction utx = ExceptionHandleUtil.getUserTransaction(); utx.begin(); // verifies if the exception thrown is correct try { sfsbContainerTransactionRuntime.insertCorrectFirstErrorSecond(DATABASE_1, DATABASE_2); } catch (Exception e) { assertTrue( ExceptionHelper.isEquals(e, expectedException), "The container did not throw the correct exception, the expected exception is " + expectedException.getName() + ", but the container threw " + e.getClass().getName()); } // tries to commit try { utx.commit(); if (!canCommit) { fail("The transaction was marked as rolled back, the client cannot make the commit."); } } catch (Exception e) { logger.debug("The bean threw an expected error during the execution {0}", e); } // verifies if the bean was discarded assertTrue( ExceptionHandleUtil.isDiscarded(sfsbContainerTransactionRuntime), "There was a runtime exception and the container did not discarded the bean."); // verifies if the transaction was rolled back if (!canCommit) { try { // verifies if the table was created in the DATABASE_1 ExceptionHandleUtil.verifyTable(DATABASE_1, ItfContainerTransaction.TABLE); fail("There was an error during the commit and the transaction was not rolled back."); } catch (SQLException e) { logger.debug("The bean threw an expected error during the execution {0}", e); } } // TODO - verifies if the container log the error. }
/** * Verifies if the container re-throws the application exception that extends a runtime exception * (with rollback = true) and marks the transaction for rollback in this case. This test uses a * client transaction. * * @param canCommit says if the bean is able to commit the client transaction. The client is able * to commit when the bean does not use the client transaction. * @throws Exception if an error during the tests occurs. */ public void testUsingClientTransWithAppRuntimeRollbackException(final boolean canCommit) throws Exception { UserTransaction utx = ExceptionHandleUtil.getUserTransaction(); utx.begin(); try { sfsbContainerTransactionApp02.insertCorrectFirstErrorSecond(DATABASE_1, DATABASE_2); fail("The container did not re-throw the application exception."); } catch (RollbackAppRuntimeException e) { logger.debug("The bean threw an expected error during the execution {0}", e); } // tries to commit try { utx.commit(); if (!canCommit) { fail("The transaction was marked as rolled back, the client cannot make the commit."); } } catch (Exception e) { logger.debug("The bean threw an expected error during the execution {0}", e); } // verifies if the table was created in the DATABASE_1 ExceptionHandleUtil.verifyTable(DATABASE_1, ItfContainerTransaction.TABLE); }
/** * Verifies if the container throws the EJBException when the bean throws a RuntimeException, * discards the bean and does the rollback in this case. * * @throws Exception if an error during the tests occurs. */ public void testNotUsingClientTransWithRuntimeException() throws Exception { // verifies if the container threw the correct exception try { sfsbContainerTransactionRuntime.insertCorrectFirstErrorSecond(DATABASE_1, DATABASE_2); fail("The container did not throw the EJBException."); } catch (EJBException e) { logger.debug("The bean threw an expected error during the execution {0}", e); } // verifies if the bean was discarded assertTrue( ExceptionHandleUtil.isDiscarded(sfsbContainerTransactionRuntime), "There was a runtime exception and the container did not discarded the bean."); // TODO - verifies if the container log the error. // verifies if the table was created in the DATABASE_1 ExceptionHandleUtil.verifyTable(DATABASE_1, ItfContainerTransaction.TABLE); }
/** * Verifies if the operations allowed for Message Driven listener methods are working properly. * * @param message msg */ public void onMessage(final Message message) { String op = null; try { op = message.getStringProperty(MessageProperty.OPERATION.toString()); } catch (JMSException e) { logger.debug("Error getting operation type: {0}", e); } if (isEqual(RESOURCE_MANAGER, op)) { DataSource ds = (DataSource) ctx.lookup("jdbc/ds01"); checkResource(ds); log( MDBListenerMethodAccess.class, ON_MESSAGE, MDBListenerMethodAccess.class, RESOURCE_MANAGER); } else if (isEqual(ENTERPRISE_BEAN, op)) { ItfOneMethod01 bean = (ItfOneMethod01) ctx.lookup("ejb/bean01"); bean.getBool(); log( MDBListenerMethodAccess.class, ON_MESSAGE, MDBListenerMethodAccess.class, ENTERPRISE_BEAN); } else if (isEqual(ENTITY_MANAGER_FACTORY, op)) { EntityManagerFactory emf = (EntityManagerFactory) ctx.lookup("persistence/pu01"); try { EMFactoryTester.checkInstance(emf, "tmpTable" + this.hashCode()); log( MDBListenerMethodAccess.class, ON_MESSAGE, MDBListenerMethodAccess.class, ENTITY_MANAGER_FACTORY); } catch (Exception e) { logger.debug("Error in EntityManagerFactory use: {0}", e); e.printStackTrace(); } } else if (isEqual(ENTITY_MANAGER, op)) { EntityManager em = (EntityManager) ctx.lookup("persistence/pctx01"); try { EntityManagerTester.checkInstance(em, "tmpTable" + this.hashCode()); log( MDBListenerMethodAccess.class, ON_MESSAGE, MDBListenerMethodAccess.class, ENTITY_MANAGER); } catch (Exception e) { logger.debug("Error in EntityManagerFactory use: {0}", e); e.printStackTrace(); } } else if (isEqual(TIMER, op)) { timer.hashCode(); log(MDBListenerMethodAccess.class, ON_MESSAGE, MDBListenerMethodAccess.class, TIMER); } else if (isEqual(USER_TRANSACTION, op)) { if (utx == null) { log( MDBListenerMethodAccess.class, ON_MESSAGE, MDBListenerMethodAccess.class, USER_TRANSACTION); } } }