Exemple #1
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldCloseResultHandlesWhenConsumeFailsInExplicitTransaction() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        internal virtual void ShouldCloseResultHandlesWhenConsumeFailsInExplicitTransaction()
        {
            KernelTransaction            transaction     = NewTransaction();
            TransactionStateMachineV1SPI stateMachineSPI = NewTransactionStateMachineSPI(transaction);
            TransactionStateMachine      stateMachine    = NewTransactionStateMachine(stateMachineSPI);

            stateMachine.BeginTransaction(null);
            stateMachine.StreamResult(boltResult =>
            {
            });
            stateMachine.Run("SOME STATEMENT", null);

            assertNotNull(stateMachine.Ctx.currentResultHandle);
            assertNotNull(stateMachine.Ctx.currentResult);

            Exception e = assertThrows(typeof(Exception), () =>
            {
                stateMachine.StreamResult(boltResult =>
                {
                    throw new Exception("some error");
                });
            });

            assertEquals("some error", e.Message);

            assertNull(stateMachine.Ctx.currentResultHandle);
            assertNull(stateMachine.Ctx.currentResult);
            assertNotNull(stateMachine.Ctx.currentTransaction);
        }
Exemple #2
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldResetInExplicitTransactionWhileStatementIsRunningWhenValidated() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        internal virtual void ShouldResetInExplicitTransactionWhileStatementIsRunningWhenValidated()
        {
            KernelTransaction            transaction     = NewTimedOutTransaction();
            TransactionStateMachineV1SPI stateMachineSPI = NewTransactionStateMachineSPI(transaction);
            TransactionStateMachine      stateMachine    = NewTransactionStateMachine(stateMachineSPI);

            // start an explicit transaction
            stateMachine.BeginTransaction(null);
            assertThat(stateMachine.StateConflict, @is(TransactionStateMachine.State.ExplicitTransaction));
            assertNotNull(stateMachine.Ctx.currentTransaction);

            stateMachine.Run("RETURN 1", null);

            // verify transaction, which is timed out
            stateMachine.ValidateTransaction();

            assertThat(stateMachine.StateConflict, @is(TransactionStateMachine.State.AutoCommit));
            assertNull(stateMachine.Ctx.currentTransaction);
            assertNull(stateMachine.Ctx.currentResult);
            assertNull(stateMachine.Ctx.currentResultHandle);

            verify(transaction, times(1)).ReasonIfTerminated;
            verify(transaction, times(1)).failure();
            verify(transaction, times(1)).close();
        }