javax.transaction.TransactionalException Java Examples

@Test
public void transformInterceptedException() {
  MessageSender sender = mock(MessageSender.class);
  SagaStartAnnotationProcessor sagaStartAnnotationProcessor = new SagaStartAnnotationProcessor(context, sender);

  doThrow(exception).when(sender).send(any(TxEvent.class));

  try {
    sagaStartAnnotationProcessor.preIntercept(null, null, 0, null, 0);
    expectFailing(TransactionalException.class);
  } catch (TransactionalException e) {
    assertThat(e.getMessage(), is("exception"));
    assertThat(e.getCause(), instanceOf(RuntimeException.class));
    assertThat(e.getCause().getMessage(), is("runtime exception"));
  }
}
 

@Test
public void neverInTx() throws SystemException {
    assertNull(OpenEJB.getTransactionManager().getTransaction());
    try {
        bean.createTx(new Runnable() {
            @Override
            public void run() {
                bean.never();
            }
        });
        fail();
    } catch (final TransactionalException e) {
        // expected
    }
    assertNull(OpenEJB.getTransactionManager().getTransaction());
}
 

@Test
public void transformInterceptedException() {
  SagaMessageSender sender = mock(SagaMessageSender.class);
  SagaStartAnnotationProcessor sagaStartAnnotationProcessor = new SagaStartAnnotationProcessor(
      context, sender);

  doThrow(exception).when(sender).send(any(TxEvent.class));

  try {
    sagaStartAnnotationProcessor.preIntercept(0);
    expectFailing(TransactionalException.class);
  } catch (TransactionalException e) {
    assertThat(e.getMessage(), is("exception"));
    assertThat(e.getCause(), instanceOf(RuntimeException.class));
    assertThat(e.getCause().getMessage(), is("runtime exception"));
  }
}
 

@Override
protected State start() {
    try {
        final Transaction transaction = transactionManager.getTransaction();
        final Transaction current;
        if (transaction == null) {
            transactionManager.begin();
            current = transactionManager.getTransaction();
        } else {
            current = transaction;
        }
        return new State(transaction, current);
    } catch (final SystemException | NotSupportedException se) {
        throw new TransactionalException(se.getMessage(), se);
    }
}
 

@Override
protected State start() {
    try {
        if (transactionManager.getTransaction() != null) {
            throw new TransactionalException("@Transactional(NEVER) but a transaction is running", new IllegalStateException());
        }
        return STATE;
    } catch (final SystemException e) {
        throw new TransactionalException(e.getMessage(), e);
    }
}
 

@AroundInvoke
public Object intercept(final InvocationContext ic) throws Exception {
    try {
        return super.intercept(ic);
    } catch (final RemoteException re) {
        throw new TransactionalException(re.getMessage(), new InvalidTransactionException(re.getMessage()));
    }
}
 

@Test
public void canUseDeclarativeTxControl() throws Exception {
    try {
        transactionalTestService.doSomething();
        fail("Exception raised due to missing yet required transaction wasn't raised");
    }
    catch(TransactionalException e) {
        assertThat(e.getMessage().contains("ARJUNA016110"));
    }

    ut.begin();
    assertThat(transactionalTestService.doSomething()).isEqualTo("Success");
    ut.rollback();
}
 

@Override
protected void commit(final State state) {
    if (state.old != null) {
        try {
            transactionManager.resume(state.old);
        } catch (final InvalidTransactionException | SystemException e) {
            throw new TransactionalException(e.getMessage(), e);
        }
    }
}
 

@Override
protected State start() {
    try {
        final Transaction tx = transactionManager.getTransaction();
        return new State(tx, null);
    } catch (final SystemException e) {
        throw new TransactionalException(e.getMessage(), e);
    }
}
 

@Override
public Response toResponse(final TransactionalException ejbException) {
    final Throwable cause = ejbException.getCause();
    if (cause != null) {
        final Class causeClass = cause.getClass();
        final ExceptionMapper exceptionMapper = providers.getExceptionMapper(causeClass);
        if (exceptionMapper == null) {
            return defaultResponse(cause);
        }
        return exceptionMapper.toResponse(cause);
    }
    return defaultResponse(ejbException);
}
 

@Override
protected State start() {
    try {
        final Transaction transaction = transactionManager.getTransaction();
        return new State(transaction, transaction);
    } catch (final SystemException e) {
        throw new TransactionalException(e.getMessage(), e);
    }
}
 

@Override
protected void commit(final State state) {
    if (state.old != state.current) {
        try {
            state.current.commit();
        } catch (final HeuristicMixedException | HeuristicRollbackException | RollbackException | SystemException e) {
            throw new TransactionalException(e.getMessage(), e);
        }
    }
}
 

@Override
protected State start() {
    try {
        final Transaction transaction = transactionManager.suspend();
        transactionManager.begin();
        return new State(transaction, transactionManager.getTransaction());
    } catch (final SystemException | NotSupportedException se) {
        throw new TransactionalException(se.getMessage(), se);
    }
}
 

@Override
protected State start() {
    final Transaction transaction;
    try {
        transaction = transactionManager.getTransaction();
    } catch (final SystemException e) {
        throw new TransactionalException(e.getMessage(), e);
    }
    return new State(transaction, transaction);
}
 

@Override
public AlphaResponse preIntercept(String parentTxId, String compensationMethod, int timeout, String retriesMethod,
    int retries, Object... message) {
  try {
    return sender.send(new SagaStartedEvent(omegaContext.globalTxId(), omegaContext.localTxId(), timeout, omegaContext.category()));
  } catch (OmegaException e) {
    throw new TransactionalException(e.getMessage(), e.getCause());
  }
}
 

@Override
public <T> T doInTransaction(Callable<T> callable) {
	try {
		return impl.doInTransaction(callable);
	}
	catch (TransactionalException e) {
		// unwrap since not usable, cause more interesting
		// (validationException, etc.)
		Throwable cause = e.getCause();
		if (cause instanceof RuntimeException) {
			throw (RuntimeException) cause;
		}
		throw e;
	}
}
 

@Test
public void testSendTccStartEventFailed() {
  throwException = true;
  try {
    tccStartAnnotationProcessor
        .preIntercept(null, "TccStartMethod", 0);
    expectFailing(TransactionalException.class);
  } catch (TransactionalException e) {
    Assert.assertThat(e.getMessage(), Is.is("exception"));
    Assert.assertThat(e.getCause(), instanceOf(RuntimeException.class));
    Assert.assertThat(e.getCause().getMessage(), Is.is("runtime exception"));
  }

}
 

public AlphaResponse preIntercept(String parentTxId, String methodName, int timeout) {
  try {
    return tccMessageSender.tccTransactionStart(new TccStartedEvent(omegaContext.globalTxId(), omegaContext.localTxId()));
  } catch (OmegaException e) {
    throw new TransactionalException(e.getMessage(), e.getCause());
  }
}
 

public AlphaResponse preIntercept(int timeout) {
  try {
    return sender
        .send(new SagaStartedEvent(omegaContext.globalTxId(), omegaContext.localTxId(), timeout));
  } catch (OmegaException e) {
    throw new TransactionalException(e.getMessage(), e.getCause());
  }
}
 

@Test
public void testTransactionalExceptionNotToBeUnwrapped() throws Exception {
	Callable callable = Mockito.mock(Callable.class);
	Mockito.when(callable.call()).thenThrow(new TransactionalException("a", new IOException("b")));
	try {
		runner.doInTransaction(callable);
		Assert.fail();
	} catch (TransactionalException e) {
		Assert.assertEquals("a", e.getMessage());
	}
	Mockito.verify(callable, Mockito.times(1)).call();
}
 

@Test
public void testTransactionalRuntimeExceptionToBeUnwrapped() throws Exception {
	Callable callable = Mockito.mock(Callable.class);
	Mockito.when(callable.call()).thenThrow(new TransactionalException("a", new IllegalStateException("b")));
	try {
		runner.doInTransaction(callable);
		Assert.fail();
	} catch (IllegalStateException e) {
		Assert.assertEquals("b", e.getMessage());
	}
	Mockito.verify(callable, Mockito.times(1)).call();
}
 

@Override
public <T> T doInTransaction(Callable<T> callable) {
	try {
		return impl.doInTransaction(callable);
	} catch (TransactionalException e) {
		// unwrap since not usable, cause more interesting
		// (validationException, etc.)
		Throwable cause = e.getCause();
		if (cause instanceof RuntimeException) {
			throw (RuntimeException) cause;
		}
		throw e;
	}
}
 

@Override
protected Object doIntercept(TransactionManager tm, Transaction tx, InvocationContext ic) throws Exception {
    if (tx == null) {
        throw new TransactionalException(jtaLogger.i18NLogger.get_tx_required(), new TransactionRequiredException());
    }
    return invokeInCallerTx(ic, tx);
}
 

@Override
protected Object doIntercept(TransactionManager tm, Transaction tx, InvocationContext ic) throws Exception {
    if (tx != null) {
        throw new TransactionalException(jtaLogger.i18NLogger.get_tx_required(), new InvalidTransactionException());
    }
    return invokeInNoTx(ic);
}
 

@Test(expected = TransactionalException.class)
public void mandatoryKO() {
    for (int i = 0; i < 2; i++) {
        bean.withoutATxIllThrowAnException();
    }
}