@Test public void shouldPropagateSystemExceptionFromBegin() throws Exception { // given AbstractTransactionManager txManager = mock(AbstractTransactionManager.class); when(txManager.suspend()).thenReturn(mock(javax.transaction.Transaction.class)); SystemException exception = new SystemException(); doThrow(exception).when(txManager).begin(); @SuppressWarnings("unchecked") Transactor.Work<Object, KernelException> work = mock(Transactor.Work.class); Transactor transactor = new Transactor(txManager); // when try { transactor.execute(work); fail("expected exception"); } // then catch (BeginTransactionFailureException e) { assertSame(exception, e.getCause()); } verifyZeroInteractions(work); verify(txManager).suspend(); verify(txManager).begin(); verifyNoMoreInteractions(txManager); }
@Test public void shouldThrowNotInTransactionExceptionWhenNotInTransaction() throws Exception { // Given AbstractTransactionManager txManager = mock(AbstractTransactionManager.class); when(txManager.getKernelTransaction()).thenReturn(null); ThreadToStatementContextBridge bridge = new ThreadToStatementContextBridge(null, txManager); // When try { bridge.statement(); fail("Should throw"); } catch (NotInTransactionException e) { // Good } }
public ResourceHolder getResource() { TransactionState txState = transactionManager.getTransactionState(); ResourceHolder resource = txState.getNeoStoreTransaction(); if (resource == null) { txState.setNeoStoreTransaction(resource = createResource(getCurrentTransaction())); } return resource; }
@Test public void shouldRollbackFailingStatement() throws Exception { // given AbstractTransactionManager txManager = mock(AbstractTransactionManager.class); javax.transaction.Transaction existingTransaction = mock(javax.transaction.Transaction.class); when(txManager.suspend()).thenReturn(existingTransaction); StatementOperationParts operations = mock(StatementOperationParts.class); KernelStatement statement = mock(KernelStatement.class); StubKernelTransaction kernelTransaction = spy(new StubKernelTransaction(operations, statement)); when(txManager.getKernelTransaction()).thenReturn(kernelTransaction); @SuppressWarnings("unchecked") Transactor.Work<Object, KernelException> work = mock(Transactor.Work.class); SpecificKernelException exception = new SpecificKernelException(); when(work.perform(any(StatementOperationParts.class), any(KernelStatement.class))) .thenThrow(exception); Transactor transactor = new Transactor(txManager); // when try { transactor.execute(work); fail("expected exception"); } // then catch (SpecificKernelException e) { assertSame(exception, e); } InOrder order = inOrder(txManager, kernelTransaction, operations, statement, work); order.verify(txManager).suspend(); order.verify(txManager).begin(); order.verify(txManager).getKernelTransaction(); order.verify(kernelTransaction).newStatement(); order.verify(work).perform(operations, statement); order.verify(statement).close(); order.verify(kernelTransaction).rollback(); order.verify(txManager).resume(existingTransaction); order.verifyNoMoreInteractions(); }
public boolean hasCurrentTransaction() { try { if (null == transactionManager || null == transactionManager.getTransaction()) { return false; } } catch (SystemException se) { throw new TransactionFailureException( "Error fetching transaction " + "for current thread", se); } return true; }
public Transaction getCurrentTransaction() throws NotInTransactionException { try { Transaction tx = transactionManager.getTransaction(); if (tx == null) { throw new NotInTransactionException(); } return tx; } catch (SystemException se) { throw new TransactionFailureException( "Error fetching transaction " + "for current thread", se); } }
private ResourceHolder createResource(Transaction tx) { try { XaConnection xaConnection = persistenceSource.getXaDataSource().getXaConnection(); NeoStoreTransaction resource = persistenceSource.createTransaction(xaConnection); ResourceHolder result = new ResourceHolder(tx, xaConnection, resource); TransactionState state = transactionManager.getTransactionState(); tx.registerSynchronization(new ResourceCleanupHook(tx, state, result)); return result; } catch (RollbackException | SystemException e) { throw new ResourceAcquisitionFailedException(e); } }
void setRollbackOnly() { try { transactionManager.setRollbackOnly(); } catch (IllegalStateException e) { // this exception always get generated in a finally block and // when it happens another exception has already been thrown // (most likley NotInTransactionException) logger.debug("Failed to set transaction rollback only", e); } catch (javax.transaction.SystemException se) { // our TM never throws this exception logger.error("Failed to set transaction rollback only", se); } }
@Test public void shouldCommitSuccessfulStatement() throws Exception { // given AbstractTransactionManager txManager = mock(AbstractTransactionManager.class); javax.transaction.Transaction existingTransaction = mock(javax.transaction.Transaction.class); when(txManager.suspend()).thenReturn(existingTransaction); StatementOperationParts operations = mock(StatementOperationParts.class); KernelStatement statement = mock(KernelStatement.class); StubKernelTransaction kernelTransaction = spy(new StubKernelTransaction(operations, statement)); when(txManager.getKernelTransaction()).thenReturn(kernelTransaction); @SuppressWarnings("unchecked") Transactor.Work<Object, KernelException> work = mock(Transactor.Work.class); Object expectedResult = new Object(); when(work.perform(eq(operations), any(KernelStatement.class))).thenReturn(expectedResult); Transactor transactor = new Transactor(txManager); // when Object result = transactor.execute(work); // then assertEquals(expectedResult, result); InOrder order = inOrder(txManager, kernelTransaction, statement, work); order.verify(txManager).suspend(); order.verify(txManager).begin(); order.verify(txManager).getKernelTransaction(); order.verify(kernelTransaction).newStatement(); order.verify(work).perform(operations, statement); order.verify(statement).close(); order.verify(kernelTransaction).commit(); order.verify(txManager).resume(existingTransaction); order.verifyNoMoreInteractions(); }
private void assertInTransaction() { txManager.assertInTransaction(); }
TransactionState getTransactionState() { return transactionManager.getTransactionState(); }