//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldProcessDiscardAllMessage() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldProcessDiscardAllMessage() { BoltStateMachineState newState = _state.process(DiscardAllMessage.INSTANCE, _context); assertEquals(_state, newState); // remains in failed state assertTrue(_connectionState.hasPendingIgnore()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @ParameterizedTest @ValueSource(strings = {"rollback", "ROLLBACK", " rollback ", " RoLlBaCk ; "}) void shouldRollbackTransaction(String statement) throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldRollbackTransaction(string statement) { BoltStateMachineState newState = _state.process(new RunMessage(statement), _context); assertEquals(_streamingState, newState); verify(_statementProcessor).rollbackTransaction(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldHandleFailureDuringResetMessageProcessing() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldHandleFailureDuringResetMessageProcessing() { when(_context.resetMachine()).thenReturn(false); // reset failed BoltStateMachineState newState = _state.process(ResetMessage.INSTANCE, _context); assertEquals(_failedState, newState); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldProcessRunMessage() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldProcessRunMessage() { BoltStateMachineState newState = _state.process(new RunMessage("RETURN 1", EMPTY_MAP), _context); assertEquals(_state, newState); // remains in failed state assertTrue(_connectionState.hasPendingIgnore()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldBeginTransactionWithoutBookmark() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldBeginTransactionWithoutBookmark() { BoltStateMachineState newState = _state.process(new RunMessage("BEGIN", EMPTY_MAP), _context); assertEquals(_streamingState, newState); verify(_statementProcessor).beginTransaction(null); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldProcessResetMessage() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldProcessResetMessage() { when(_context.resetMachine()).thenReturn(true); // reset successful BoltStateMachineState newState = _state.process(ResetMessage.INSTANCE, _context); assertEquals(_readyState, newState); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldNotProcessUnsupportedMessage() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldNotProcessUnsupportedMessage() { RequestMessage unsupportedMessage = mock(typeof(RequestMessage)); BoltStateMachineState newState = _state.process(unsupportedMessage, _context); assertNull(newState); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldBeginTransactionWithMultipleBookmarks() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldBeginTransactionWithMultipleBookmarks() { IDictionary <string, object> @params = map("bookmarks", asList("neo4j:bookmark:v1:tx7", "neo4j:bookmark:v1:tx1", "neo4j:bookmark:v1:tx92", "neo4j:bookmark:v1:tx39")); BoltStateMachineState newState = _state.process(new RunMessage("BEGIN", asMapValue(@params)), _context); assertEquals(_streamingState, newState); verify(_statementProcessor).beginTransaction(new Bookmark(92)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldProcessAckFailureMessageWithPendingIgnore() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldProcessAckFailureMessageWithPendingIgnore() { _connectionState.markIgnored(); assertTrue(_connectionState.hasPendingIgnore()); BoltStateMachineState newState = _state.process(AckFailureMessage.INSTANCE, _context); assertEquals(_readyState, newState); assertFalse(_connectionState.hasPendingIgnore()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldProcessResetMessageWithPerndingIgnore() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldProcessResetMessageWithPerndingIgnore() { when(_context.resetMachine()).thenReturn(true); // reset successful _connectionState.markIgnored(); assertTrue(_connectionState.hasPendingIgnore()); BoltStateMachineState newState = _state.process(ResetMessage.INSTANCE, _context); assertEquals(_readyState, newState); assertFalse(_connectionState.hasPendingIgnore()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldProcessDiscardAllMessage() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldProcessDiscardAllMessage() { StatementProcessor statementProcessor = mock(typeof(StatementProcessor)); _connectionState.StatementProcessor = statementProcessor; BoltStateMachineState nextState = _state.process(DiscardAllMessage.INSTANCE, _context); assertEquals(_readyState, nextState); verify(statementProcessor).streamResult(any()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldHandleFailureDuringRunMessageProcessing() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldHandleFailureDuringRunMessageProcessing() { Exception error = new Exception("Hello"); when(_statementProcessor.run(any(), any())).thenThrow(error); BoltStateMachineState nextState = _state.process(new RunMessage("RETURN 1", EMPTY_MAP), _context); assertEquals(_failedState, nextState); verify(_context).handleFailure(error, false); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldProcessAckFailureMessageWithPendingError() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldProcessAckFailureMessageWithPendingError() { Neo4jError error = Neo4jError.from(new Exception()); _connectionState.markFailed(error); assertEquals(error, _connectionState.PendingError); BoltStateMachineState newState = _state.process(AckFailureMessage.INSTANCE, _context); assertEquals(_readyState, newState); assertNull(_connectionState.PendingError); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldProcessResetMessageWhenInterrupted() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldProcessResetMessageWhenInterrupted() { _connectionState.incrementInterruptCounter(); _connectionState.incrementInterruptCounter(); assertTrue(_connectionState.Interrupted); assertFalse(_connectionState.hasPendingIgnore()); BoltStateMachineState newState = _state.process(ResetMessage.INSTANCE, _context); assertEquals(_state, newState); // remains in interrupted state assertTrue(_connectionState.hasPendingIgnore()); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void nextState(org.neo4j.bolt.messaging.RequestMessage message, org.neo4j.bolt.runtime.StateMachineContext context) throws org.neo4j.bolt.runtime.BoltConnectionFatality private void NextState(RequestMessage message, StateMachineContext context) { BoltStateMachineState preState = _state; _state = _state.process(message, context); if (_state == null) { string msg = "Message '" + message + "' cannot be handled by a session in the " + preState.Name() + " state."; Fail(Neo4jError.fatalFrom(Org.Neo4j.Kernel.Api.Exceptions.Status_Request.Invalid, msg)); throw new BoltProtocolBreachFatality(msg); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldProcessResetMessageWithPerndingError() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldProcessResetMessageWithPerndingError() { when(_context.resetMachine()).thenReturn(true); // reset successful Neo4jError error = Neo4jError.from(new Exception()); _connectionState.markFailed(error); assertEquals(error, _connectionState.PendingError); BoltStateMachineState newState = _state.process(ResetMessage.INSTANCE, _context); assertEquals(_readyState, newState); assertNull(_connectionState.PendingError); }
public BoltStateMachineV1(BoltStateMachineSPI spi, BoltChannel boltChannel, Clock clock) { this._id = boltChannel.Id(); this._boltChannel = boltChannel; this._spi = spi; this.ConnectionStateConflict = new MutableConnectionState(); this._context = new BoltStateMachineV1Context(this, boltChannel, spi, ConnectionStateConflict, clock); States states = BuildStates(); this._state = states.Initial; this._failedState = states.Failed; }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldHandleErrorWhenProcessingDiscardAllMessage() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldHandleErrorWhenProcessingDiscardAllMessage() { Exception error = new Exception("Hello"); StatementProcessor statementProcessor = mock(typeof(StatementProcessor)); doThrow(error).when(statementProcessor).streamResult(any()); _connectionState.StatementProcessor = statementProcessor; BoltStateMachineState nextState = _state.process(DiscardAllMessage.INSTANCE, _context); assertEquals(_failedState, nextState); verify(_context).handleFailure(error, false); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldIgnoreMessagesOtherThanInterruptAndReset() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldIgnoreMessagesOtherThanInterruptAndReset() { IList <RequestMessage> messages = new IList <RequestMessage> { AckFailureMessage.INSTANCE, PullAllMessage.INSTANCE, DiscardAllMessage.INSTANCE, new RunMessage("RETURN 1", EMPTY_MAP), new InitMessage("Driver", emptyMap()) }; foreach (RequestMessage message in messages) { _connectionState.resetPendingFailedAndIgnored(); BoltStateMachineState newState = _state.process(message, _context); assertEquals(_state, newState); // remains in interrupted state assertTrue(_connectionState.hasPendingIgnore()); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void handleExternalFailure(org.neo4j.bolt.runtime.Neo4jError error, org.neo4j.bolt.runtime.BoltResponseHandler handler) throws org.neo4j.bolt.runtime.BoltConnectionFatality public override void HandleExternalFailure(Neo4jError error, BoltResponseHandler handler) { Before(handler); try { if (ConnectionStateConflict.canProcessMessage()) { Fail(error); _state = _failedState; } } finally { After(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldProcessRunMessage() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldProcessRunMessage() { StatementMetadata statementMetadata = mock(typeof(StatementMetadata)); when(statementMetadata.FieldNames()).thenReturn(new string[] { "foo", "bar", "baz" }); when(_statementProcessor.run(any(), any())).thenReturn(statementMetadata); BoltResponseHandler responseHandler = mock(typeof(BoltResponseHandler)); _connectionState.ResponseHandler = responseHandler; BoltStateMachineState nextState = _state.process(new RunMessage("RETURN 1", EMPTY_MAP), _context); assertEquals(_streamingState, nextState); verify(_statementProcessor).run("RETURN 1", EMPTY_MAP); verify(responseHandler).onMetadata("fields", stringArray("foo", "bar", "baz")); verify(responseHandler).onMetadata(eq("result_available_after"), any()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldAddServerVersionMetadataOnHelloMessage() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldAddServerVersionMetadataOnHelloMessage() { // Given // hello message IDictionary <string, object> meta = map("user_agent", "3.0", PRINCIPAL, "neo4j", CREDENTIALS, "password"); HelloMessage helloMessage = new HelloMessage(meta); // setup state machine ConnectedState state = new ConnectedState(); BoltStateMachineState readyState = mock(typeof(BoltStateMachineState)); StateMachineContext context = mock(typeof(StateMachineContext)); BoltStateMachineSPI boltSpi = mock(typeof(BoltStateMachineSPI), RETURNS_MOCKS); MutableConnectionState connectionState = new MutableConnectionState(); state.ReadyState = readyState; when(context.BoltSpi()).thenReturn(boltSpi); when(context.ConnectionState()).thenReturn(connectionState); when(boltSpi.Version()).thenReturn("42.42.42"); MutableConnectionState connectionStateMock = mock(typeof(MutableConnectionState)); when(context.ConnectionState()).thenReturn(connectionStateMock); when(context.ConnectionId()).thenReturn("connection-uuid"); when(boltSpi.Authenticate(meta)).thenReturn(AuthenticationResult.AUTH_DISABLED); // When BoltStateMachineState newState = state.Process(helloMessage, context); // Then assertEquals(readyState, newState); verify(connectionStateMock).onMetadata("server", stringValue("42.42.42")); verify(connectionStateMock).onMetadata(eq("connection_id"), any(typeof(StringValue))); }
public override void MarkFailed(Neo4jError error) { Fail(error); _state = _failedState; }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldProcessInterruptMessage() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldProcessInterruptMessage() { BoltStateMachineState newState = _state.process(InterruptSignal.INSTANCE, _context); assertEquals(_interruptedState, newState); }
public States(BoltStateMachineState initial, BoltStateMachineState failed) { this.Initial = initial; this.Failed = failed; }