protected internal BoltRequestMessageReader(BoltConnection connection, BoltResponseHandler externalErrorResponseHandler, IList <RequestMessageDecoder> decoders) { this._connection = connection; this._externalErrorResponseHandler = externalErrorResponseHandler; //JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter: this._decoders = decoders.ToDictionary(RequestMessageDecoder::signature, identity()); }
private static IList <RequestMessageDecoder> BuildDecoders(BoltConnection connection, BoltResponseMessageWriter responseMessageWriter, LogService logService) { BoltResponseHandler resultHandler = new ResultHandler(responseMessageWriter, connection, InternalLog(logService)); BoltResponseHandler defaultHandler = NewSimpleResponseHandler(responseMessageWriter, connection, logService); return(Arrays.asList(new HelloMessageDecoder(defaultHandler), new RunMessageDecoder(defaultHandler), new DiscardAllMessageDecoder(resultHandler), new PullAllMessageDecoder(resultHandler), new BeginMessageDecoder(defaultHandler), new CommitMessageDecoder(resultHandler), new RollbackMessageDecoder(resultHandler), new ResetMessageDecoder(connection, defaultHandler), new GoodbyeMessageDecoder(connection, defaultHandler) )); }
private static IList <RequestMessageDecoder> BuildDecoders(BoltConnection connection, BoltResponseMessageWriter responseMessageWriter, LogService logService) { BoltResponseHandler initHandler = NewSimpleResponseHandler(connection, responseMessageWriter, logService); BoltResponseHandler runHandler = NewSimpleResponseHandler(connection, responseMessageWriter, logService); BoltResponseHandler resultHandler = new ResultHandler(responseMessageWriter, connection, InternalLog(logService)); BoltResponseHandler defaultHandler = NewSimpleResponseHandler(connection, responseMessageWriter, logService); return(Arrays.asList(new InitMessageDecoder(initHandler), new AckFailureMessageDecoder(defaultHandler), new ResetMessageDecoder(connection, defaultHandler), new RunMessageDecoder(runHandler), new DiscardAllMessageDecoder(resultHandler), new PullAllMessageDecoder(resultHandler) )); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void before(org.neo4j.bolt.runtime.BoltResponseHandler handler) throws org.neo4j.bolt.runtime.BoltConnectionFatality private void Before(BoltResponseHandler handler) { if (ConnectionStateConflict.Terminated) { Close(); } else if (ConnectionStateConflict.Interrupted) { NextState(InterruptSignal.INSTANCE, _context); } ConnectionStateConflict.ResponseHandler = handler; }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldMoveToFailedOnRun_fail() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldMoveToFailedOnRunFail() { BoltStateMachineV3 machine = BoltStateMachineInTxReadyState; // When BoltResponseHandler handler = mock(typeof(BoltResponseHandler)); doThrow(new Exception("Error!")).when(handler).onRecords(any(), anyBoolean()); machine.Process(new RunMessage("A cypher query"), handler); // Then assertThat(machine.State(), instanceOf(typeof(FailedState))); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @ParameterizedTest @MethodSource("pullAllDiscardAllMessages") void shouldMoveFromStreamingStateToFailedStateOnPullAllOrDiscardAll_fail(org.neo4j.bolt.messaging.RequestMessage message) throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldMoveFromStreamingStateToFailedStateOnPullAllOrDiscardAllFail(RequestMessage message) { // Given BoltStateMachineV3 machine = BoltStateMachineInStreamingState; // When BoltResponseHandler handler = mock(typeof(BoltResponseHandler)); doThrow(new Exception("Fail")).when(handler).onRecords(any(), anyBoolean()); machine.Process(message, handler); // Then assertThat(machine.State(), instanceOf(typeof(FailedState))); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void process(org.neo4j.bolt.messaging.RequestMessage message, org.neo4j.bolt.runtime.BoltResponseHandler handler) throws org.neo4j.bolt.runtime.BoltConnectionFatality public override void Process(RequestMessage message, BoltResponseHandler handler) { Before(handler); try { if (message.SafeToProcessInAnyState() || ConnectionStateConflict.canProcessMessage()) { NextState(message, _context); } } finally { After(); } }
//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 public void shouldHandleErrorThatCausesFailureMessage() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldHandleErrorThatCausesFailureMessage() { Neo4jPack_Unpacker unpacker = mock(typeof(Neo4jPack_Unpacker)); BoltIOException error = new BoltIOException(Org.Neo4j.Kernel.Api.Exceptions.Status_General.UnknownError, "Hello"); when(unpacker.UnpackStructHeader()).thenThrow(error); BoltStateMachine stateMachine = mock(typeof(BoltStateMachine)); BoltConnection connection = new SynchronousBoltConnection(stateMachine); BoltResponseHandler externalErrorResponseHandler = ResponseHandlerMock(); BoltRequestMessageReader reader = new TestBoltRequestMessageReader(connection, externalErrorResponseHandler, emptyList()); reader.Read(unpacker); verify(stateMachine).handleExternalFailure(Neo4jError.from(error), externalErrorResponseHandler); }
//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 public void shouldDecodeKnownMessage() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldDecodeKnownMessage() { Neo4jPack_Unpacker unpacker = mock(typeof(Neo4jPack_Unpacker)); when(unpacker.UnpackStructSignature()).thenReturn('a'); RequestMessage message = mock(typeof(RequestMessage)); BoltResponseHandler responseHandler = ResponseHandlerMock(); RequestMessageDecoder decoder = new TestRequestMessageDecoder('a', responseHandler, message); BoltStateMachine stateMachine = mock(typeof(BoltStateMachine)); BoltConnection connection = new SynchronousBoltConnection(stateMachine); BoltRequestMessageReader reader = new TestBoltRequestMessageReader(connection, ResponseHandlerMock(), singletonList(decoder)); reader.Read(unpacker); verify(stateMachine).process(message, responseHandler); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void doRead(Neo4jPack_Unpacker unpacker) throws java.io.IOException private void DoRead(Neo4jPack_Unpacker unpacker) { try { unpacker.UnpackStructHeader(); int signature = unpacker.UnpackStructSignature(); RequestMessageDecoder decoder = _decoders[signature]; if (decoder == null) { throw new BoltIOException(Org.Neo4j.Kernel.Api.Exceptions.Status_Request.InvalidFormat, string.Format("Message 0x{0} is not a valid message signature.", signature.ToString("x"))); } RequestMessage message = decoder.Decode(unpacker); BoltResponseHandler responseHandler = decoder.ResponseHandler(); _connection.enqueue(stateMachine => stateMachine.process(message, responseHandler)); } catch (PackStream.PackStreamException e) { throw new BoltIOException(Org.Neo4j.Kernel.Api.Exceptions.Status_Request.InvalidFormat, string.Format("Unable to read message type. Error was: {0}.", e.Message), e); } }
public HelloMessageDecoder(BoltResponseHandler responseHandler) { this._responseHandler = responseHandler; }
public virtual void AttachTo(BoltResponseHandler state) { state.OnMetadata(BOOKMARK_KEY, stringValue(ToString())); }
internal TestRequestMessageDecoder(int signature, BoltResponseHandler responseHandler, RequestMessage message) { this.SignatureConflict = signature; this.ResponseHandlerConflict = responseHandler; this.Message = message; }
internal TestBoltRequestMessageReader(BoltConnection connection, BoltResponseHandler externalErrorResponseHandler, IList <RequestMessageDecoder> decoders) : base(connection, externalErrorResponseHandler, decoders) { }