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)
{
}
