@Override public void success() { successCalled = true; transaction.success(); }
@Override public void success() { internal.success(); }
private void commitTx() throws TransactionFailureException { tx.success(); tx.close(); }
public void commit() { try { KernelTransaction kernelTransactionBoundToThisThread = bridge.getKernelTransactionBoundToThisThread( true ); kernelTransactionBoundToThisThread.success(); kernelTransactionBoundToThisThread.close(); } catch ( NotInTransactionException e ) { // if the transaction was already terminated there is nothing more to do } catch ( TransactionFailureException e ) { throw new RuntimeException( e ); } finally { bridge.unbindTransactionFromCurrentThread(); } }
void closeTransaction( MutableTransactionState ctx, boolean success ) throws TransactionFailureException { KernelTransaction tx = ctx.currentTransaction; ctx.currentTransaction = null; if ( tx != null ) { try { if ( success ) { tx.success(); } else { tx.failure(); } if ( tx.isOpen() ) { tx.close(); } } finally { ctx.currentTransaction = null; } } }
@Test public void successCannotOverrideFailure() { // When placeboTx.failure(); placeboTx.success(); placeboTx.close(); // Then verify( kernelTransaction ).failure(); verify( kernelTransaction, never() ).success(); }
@Test public void shouldCommitSuccessfulTransaction() throws Exception { // GIVEN try ( KernelTransaction transaction = newTransaction( loginContext() ) ) { // WHEN transactionInitializer.accept( transaction ); transaction.success(); } // THEN verify( transactionMonitor, times( 1 ) ).transactionFinished( true, isWriteTx ); verifyExtraInteractionWithTheMonitor( transactionMonitor, isWriteTx ); }
@Test public void shouldIgnoreTerminateAfterCommit() throws Exception { KernelTransaction transaction = newTransaction( loginContext() ); transactionInitializer.accept( transaction ); transaction.success(); transaction.close(); transaction.markForTermination( Status.General.UnknownError ); // THEN verify( transactionMonitor, times( 1 ) ).transactionFinished( true, isWriteTx ); verifyExtraInteractionWithTheMonitor( transactionMonitor, isWriteTx ); }
@Test( expected = TransactionTerminatedException.class ) public void shouldThrowOnTerminationInCommit() throws Exception { KernelTransaction transaction = newTransaction( loginContext() ); transactionInitializer.accept( transaction ); transaction.success(); transaction.markForTermination( Status.General.UnknownError ); transaction.close(); }
@Test public void shouldRollbackOnClosingTerminatedTransaction() { // GIVEN KernelTransaction transaction = newTransaction( loginContext() ); transactionInitializer.accept( transaction ); transaction.success(); transaction.markForTermination( Status.General.UnknownError ); try { // WHEN transaction.close(); fail( "Exception expected" ); } catch ( Exception e ) { assertThat( e, instanceOf( TransactionTerminatedException.class ) ); } // THEN verify( transactionMonitor, times( 1 ) ).transactionFinished( false, isWriteTx ); verify( transactionMonitor, times( 1 ) ).transactionTerminated( isWriteTx ); verifyExtraInteractionWithTheMonitor( transactionMonitor, isWriteTx ); }
@Test public void shouldRollbackAndThrowOnFailedAndSuccess() { // GIVEN boolean exceptionReceived = false; try ( KernelTransaction transaction = newTransaction( loginContext() ) ) { // WHEN transactionInitializer.accept( transaction ); transaction.failure(); transaction.success(); } catch ( TransactionFailureException e ) { // Expected. exceptionReceived = true; } // THEN assertTrue( exceptionReceived ); verify( transactionMonitor, times( 1 ) ).transactionFinished( false, isWriteTx ); verifyExtraInteractionWithTheMonitor( transactionMonitor, isWriteTx ); }
@Test public void shouldRollbackOnClosingTerminatedButSuccessfulTransaction() { // GIVEN KernelTransaction transaction = newTransaction( loginContext() ); transactionInitializer.accept( transaction ); transaction.markForTermination( Status.General.UnknownError ); transaction.success(); assertEquals( Status.General.UnknownError, transaction.getReasonIfTerminated().get() ); try { // WHEN transaction.close(); fail( "Exception expected" ); } catch ( Exception e ) { assertThat( e, instanceOf( TransactionTerminatedException.class ) ); } // THEN verify( transactionMonitor, times( 1 ) ).transactionFinished( false, isWriteTx ); verify( transactionMonitor, times( 1 ) ).transactionTerminated( isWriteTx ); verifyExtraInteractionWithTheMonitor( transactionMonitor, isWriteTx ); }
transaction.success(); latch.startAndWaitForAllToStartAndFinish();
@Test( expected = TransactionTerminatedException.class ) public void shouldThrowTerminateExceptionWhenTransactionTerminated() throws KernelException { KernelTransaction transaction = newTransaction( AnonymousContext.write() ); transaction.success(); transaction.markForTermination( Status.General.UnknownError ); transactionOperation.operate( transaction.dataRead(), transaction.dataWrite(), transaction.schemaRead() ); }
@Test( expected = NotInTransactionException.class ) public void shouldThrowNotInTransactionWhenTransactionClosedAndAccessingOperations() throws KernelException { KernelTransaction transaction = newTransaction( AnonymousContext.write() ); transaction.success(); transaction.close(); transactionOperation.operate( transaction.dataRead(), transaction.dataWrite(), transaction.schemaRead() ); }
@Test( expected = NotInTransactionException.class ) public void shouldThrowNotInTransactionWhenTransactionClosedAndAttemptingOperations() throws KernelException { KernelTransaction transaction = newTransaction( AnonymousContext.write() ); Read read = transaction.dataRead(); Write write = transaction.dataWrite(); SchemaRead schemaRead = transaction.schemaRead(); transaction.success(); transaction.close(); transactionOperation.operate( read, write, schemaRead ); }
@Test public void shouldIncludeRandomBytesInAdditionalHeader() throws Throwable { // Given TransactionRepresentation[] transactionRepresentation = new TransactionRepresentation[1]; KernelTransactions registry = newKernelTransactions( newRememberingCommitProcess( transactionRepresentation ) ); // When try ( KernelTransaction transaction = getKernelTransaction( registry ) ) { // Just pick anything that can flag that changes have been made to this transaction ((KernelTransactionImplementation) transaction).txState().nodeDoCreate( 0 ); transaction.success(); } // Then byte[] additionalHeader = transactionRepresentation[0].additionalHeader(); assertNotNull( additionalHeader ); assertTrue( additionalHeader.length > 0 ); }
@Override public void success() { successCalled = true; transaction.success(); }
public void commit() { try { KernelTransaction kernelTransactionBoundToThisThread = bridge.getKernelTransactionBoundToThisThread( true ); kernelTransactionBoundToThisThread.success(); kernelTransactionBoundToThisThread.close(); } catch ( NotInTransactionException e ) { // if the transaction was already terminated there is nothing more to do } catch ( TransactionFailureException e ) { throw new RuntimeException( e ); } finally { bridge.unbindTransactionFromCurrentThread(); } }
void closeTransaction( MutableTransactionState ctx, boolean success ) throws TransactionFailureException { KernelTransaction tx = ctx.currentTransaction; ctx.currentTransaction = null; if ( tx != null ) { try { if ( success ) { tx.success(); } else { tx.failure(); } if ( tx.isOpen() ) { tx.close(); } } finally { ctx.currentTransaction = null; } } }