//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(); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public static boolean processAuthentication(String userAgent, java.util.Map<String,Object> authToken, org.neo4j.bolt.runtime.StateMachineContext context) throws org.neo4j.bolt.runtime.BoltConnectionFatality public static bool ProcessAuthentication(string userAgent, IDictionary <string, object> authToken, StateMachineContext context) { try { BoltStateMachineSPI boltSpi = context.BoltSpi(); AuthenticationResult authResult = boltSpi.Authenticate(authToken); string username = authResult.LoginContext.subject().username(); context.AuthenticatedAsUser(username, userAgent); StatementProcessor statementProcessor = new TransactionStateMachine(boltSpi.TransactionSpi(), authResult, context.Clock()); context.ConnectionState().StatementProcessor = statementProcessor; if (authResult.CredentialsExpired()) { context.ConnectionState().onMetadata("credentials_expired", Values.TRUE); } context.ConnectionState().onMetadata("server", Values.stringValue(boltSpi.Version())); boltSpi.UdcRegisterClient(userAgent); return(true); } catch (Exception t) { context.HandleFailure(t, true); return(false); } }
//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); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldNotMarkForTerminationWhenNoTransaction() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldNotMarkForTerminationWhenNoTransaction() { KernelTransaction transaction = NewTransaction(); TransactionStateMachineV1SPI stateMachineSPI = NewTransactionStateMachineSPI(transaction); TransactionStateMachine stateMachine = NewTransactionStateMachine(stateMachineSPI); stateMachine.MarkCurrentTransactionForTermination(); verify(transaction, never()).markForTermination(any()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldUnbindTxAfterRun() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldUnbindTxAfterRun() { KernelTransaction transaction = NewTimedOutTransaction(); TransactionStateMachineV1SPI stateMachineSPI = NewTransactionStateMachineSPI(transaction); TransactionStateMachine stateMachine = NewTransactionStateMachine(stateMachineSPI); stateMachine.Run("SOME STATEMENT", null); verify(stateMachineSPI, times(1)).unbindTransactionFromCurrentThread(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldStartWithAutoCommitState() internal virtual void ShouldStartWithAutoCommitState() { TransactionStateMachineV1SPI stateMachineSPI = mock(typeof(TransactionStateMachineV1SPI)); TransactionStateMachine stateMachine = NewTransactionStateMachine(stateMachineSPI); assertThat(stateMachine.StateConflict, @is(TransactionStateMachine.State.AutoCommit)); assertNull(stateMachine.Ctx.currentTransaction); assertNull(stateMachine.Ctx.currentResultHandle); assertNull(stateMachine.Ctx.currentResult); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldThrowDuringRunIfPendingTerminationNoticeExists() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldThrowDuringRunIfPendingTerminationNoticeExists() { KernelTransaction transaction = NewTimedOutTransaction(); TransactionStateMachineV1SPI stateMachineSPI = NewTransactionStateMachineSPI(transaction); TransactionStateMachine stateMachine = NewTransactionStateMachine(stateMachineSPI); stateMachine.Ctx.pendingTerminationNotice = Org.Neo4j.Kernel.Api.Exceptions.Status_Transaction.TransactionTimedOut; TransactionTerminatedException e = assertThrows(typeof(TransactionTerminatedException), () => stateMachine.Run("SOME STATEMENT", null)); assertEquals(Org.Neo4j.Kernel.Api.Exceptions.Status_Transaction.TransactionTimedOut, e.Status()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldCloseResultAndTransactionHandlesWhenExecutionFails() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldCloseResultAndTransactionHandlesWhenExecutionFails() { KernelTransaction transaction = NewTransaction(); BoltResultHandle resultHandle = NewResultHandle(new Exception("some error")); TransactionStateMachineV1SPI stateMachineSPI = NewTransactionStateMachineSPI(transaction, resultHandle); TransactionStateMachine stateMachine = NewTransactionStateMachine(stateMachineSPI); Exception e = assertThrows(typeof(Exception), () => stateMachine.Run("SOME STATEMENT", null)); assertEquals("some error", e.Message); assertNull(stateMachine.Ctx.currentResultHandle); assertNull(stateMachine.Ctx.currentResult); assertNull(stateMachine.Ctx.currentTransaction); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldDoNothingInAutoCommitTransactionUponInitialisationWhenValidated() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldDoNothingInAutoCommitTransactionUponInitialisationWhenValidated() { KernelTransaction transaction = NewTimedOutTransaction(); TransactionStateMachineV1SPI stateMachineSPI = NewTransactionStateMachineSPI(transaction); TransactionStateMachine stateMachine = NewTransactionStateMachine(stateMachineSPI); // We're in auto-commit state assertThat(stateMachine.StateConflict, @is(TransactionStateMachine.State.AutoCommit)); assertNull(stateMachine.Ctx.currentTransaction); // call validate transaction stateMachine.ValidateTransaction(); assertThat(stateMachine.StateConflict, @is(TransactionStateMachine.State.AutoCommit)); assertNull(stateMachine.Ctx.currentTransaction); verify(transaction, never()).ReasonIfTerminated; verify(transaction, never()).failure(); verify(transaction, never()).close(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldNotOpenExplicitTransactionForPeriodicCommitQuery() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldNotOpenExplicitTransactionForPeriodicCommitQuery() { KernelTransaction transaction = NewTransaction(); TransactionStateMachineV1SPI stateMachineSPI = NewTransactionStateMachineSPI(transaction); when(stateMachineSPI.IsPeriodicCommit(_periodicCommitQuery)).thenReturn(true); TransactionStateMachine stateMachine = NewTransactionStateMachine(stateMachineSPI); stateMachine.Run(_periodicCommitQuery, EMPTY_MAP); // transaction was created only to stream back result of the periodic commit query assertEquals(transaction, stateMachine.Ctx.currentTransaction); InOrder inOrder = inOrder(stateMachineSPI); inOrder.verify(stateMachineSPI).isPeriodicCommit(_periodicCommitQuery); // periodic commit query was executed without starting an explicit transaction inOrder.verify(stateMachineSPI).executeQuery(any(typeof(LoginContext)), eq(_periodicCommitQuery), eq(EMPTY_MAP), any(), any()); // explicit transaction was started only after query execution to stream the result inOrder.verify(stateMachineSPI).beginTransaction(any(typeof(LoginContext)), any(), any()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @BeforeEach void createMocks() internal virtual void CreateMocks() { _stateMachineSPI = mock(typeof(TransactionStateMachineV1SPI)); _mutableState = mock(typeof(TransactionStateMachine.MutableTransactionState)); _stateMachine = new TransactionStateMachine(_stateMachineSPI, AUTH_DISABLED, new FakeClock()); }