//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private static void testLoggingOfOriginalErrorWhenOutputIsClosed(org.neo4j.bolt.runtime.Neo4jError original) throws Exception private static void TestLoggingOfOriginalErrorWhenOutputIsClosed(Neo4jError original) { PackOutputClosedException outputClosed = new PackOutputClosedException("Output closed", "<client>"); AssertableLogProvider logProvider = EmulateFailureWritingError(original, outputClosed); logProvider.AssertExactly(inLog("Test").warn(startsWith("Unable to send error back to the client"), equalTo(original.Cause()))); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void handleFailure(Throwable cause, boolean fatal) throws org.neo4j.bolt.runtime.BoltConnectionFatality public override void HandleFailure(Exception cause, bool fatal) { if (ExceptionUtils.indexOfType(cause, typeof(BoltConnectionFatality)) != -1) { fatal = true; } Neo4jError error = fatal ? Neo4jError.fatalFrom(cause) : Neo4jError.from(cause); Fail(error); if (error.Fatal) { if (ExceptionUtils.indexOfType(cause, typeof(AuthorizationExpiredException)) != -1) { throw new BoltConnectionAuthFatality("Failed to process a bolt message", cause); } if (cause is AuthenticationException) { throw new BoltConnectionAuthFatality(( AuthenticationException )cause); } throw new BoltConnectionFatality("Failed to process a bolt message", cause); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldFailWhenTryingToPackAndUnpackMapContainingNullKeys() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldFailWhenTryingToPackAndUnpackMapContainingNullKeys() { // Given PackedOutputArray output = new PackedOutputArray(); Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = _neo4jPack.newPacker(output); IDictionary <string, AnyValue> map = new Dictionary <string, AnyValue>(); map[null] = longValue(42L); map["foo"] = longValue(1337L); packer.PackMapHeader(map.Count); foreach (KeyValuePair <string, AnyValue> entry in map.SetOfKeyValuePairs()) { packer.pack(entry.Key); packer.pack(entry.Value); } // When try { PackedInputArray input = new PackedInputArray(output.Bytes()); Org.Neo4j.Bolt.messaging.Neo4jPack_Unpacker unpacker = _neo4jPack.newUnpacker(input); unpacker.Unpack(); fail("exception expected"); } catch (BoltIOException ex) { assertEquals(Neo4jError.from(Org.Neo4j.Kernel.Api.Exceptions.Status_Request.Invalid, "Value `null` is not supported as key in maps, must be a non-nullable string."), Neo4jError.from(ex)); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldThrowOnUnpackingMapWithDuplicateKeys() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldThrowOnUnpackingMapWithDuplicateKeys() { // Given PackedOutputArray output = new PackedOutputArray(); Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = _neo4jPack.newPacker(output); packer.PackMapHeader(2); packer.Pack("key"); packer.pack(intValue(1)); packer.Pack("key"); packer.pack(intValue(2)); // When try { PackedInputArray input = new PackedInputArray(output.Bytes()); Org.Neo4j.Bolt.messaging.Neo4jPack_Unpacker unpacker = _neo4jPack.newUnpacker(input); unpacker.Unpack(); fail("exception expected"); } catch (BoltIOException ex) { assertEquals(Neo4jError.from(Org.Neo4j.Kernel.Api.Exceptions.Status_Request.Invalid, "Duplicate map key `key`."), Neo4jError.from(ex)); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldCallExternalErrorOnInitWithDuplicateKeys() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldCallExternalErrorOnInitWithDuplicateKeys() { BoltStateMachine stateMachine = mock(typeof(BoltStateMachine)); SynchronousBoltConnection connection = new SynchronousBoltConnection(stateMachine); _channel = new EmbeddedChannel(NewDecoder(connection)); // Generate INIT message with duplicate keys PackedOutputArray @out = new PackedOutputArray(); Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = PackerUnderTest.newPacker(@out); packer.PackStructHeader(2, InitMessage.SIGNATURE); packer.Pack("Test/User Agent 1.0"); packer.PackMapHeader(3); packer.Pack("scheme"); packer.Pack("basic"); packer.Pack("principal"); packer.Pack("user"); packer.Pack("scheme"); packer.Pack("password"); _channel.writeInbound(Unpooled.wrappedBuffer(@out.Bytes())); _channel.finishAndReleaseAll(); verify(stateMachine).handleExternalFailure(eq(Neo4jError.from(Org.Neo4j.Kernel.Api.Exceptions.Status_Request.Invalid, "Duplicate map key `scheme`.")), any()); }
private void AssertYieldsErrors(string json, params Neo4jError[] expectedErrors) { StatementDeserializer de = new StatementDeserializer(new ByteArrayInputStreamAnonymousInnerClass(this, UTF8.encode(json))); while (de.MoveNext()) { de.Current; } IEnumerator <Neo4jError> actual = de.Errors(); IEnumerator <Neo4jError> expected = asList(expectedErrors).GetEnumerator(); while (actual.MoveNext()) { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: assertTrue(expected.hasNext()); Neo4jError error = actual.Current; //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: Neo4jError expectedError = expected.next(); assertThat(error.Message, equalTo(expectedError.Message)); assertThat(error.Status(), equalTo(expectedError.Status())); } //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: assertFalse(expected.hasNext()); }
protected internal virtual void After() { if (ConnectionStateConflict.ResponseHandler != null) { try { Neo4jError pendingError = ConnectionStateConflict.PendingError; if (pendingError != null) { ConnectionStateConflict.markFailed(pendingError); } if (ConnectionStateConflict.hasPendingIgnore()) { ConnectionStateConflict.markIgnored(); } ConnectionStateConflict.resetPendingFailedAndIgnored(); ConnectionStateConflict.ResponseHandler.onFinish(); } finally { ConnectionStateConflict.ResponseHandler = null; } } }
private void AddError(Neo4jError error) { if (_errors == null) { _errors = new LinkedList <Neo4jError>(); } _errors.Add(error); }
//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 WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private static org.neo4j.logging.AssertableLogProvider emulateFailureWritingError(org.neo4j.bolt.runtime.Neo4jError error, Throwable errorDuringWrite) throws Exception private static AssertableLogProvider EmulateFailureWritingError(Neo4jError error, Exception errorDuringWrite) { AssertableLogProvider logProvider = new AssertableLogProvider(); BoltResponseMessageWriter responseHandler = NewResponseHandlerMock(error.Fatal, errorDuringWrite); MessageProcessingHandler handler = new MessageProcessingHandler(responseHandler, mock(typeof(BoltConnection)), logProvider.GetLog("Test")); handler.MarkFailed(error); handler.OnFinish(); return(logProvider); }
private void Fail(Neo4jError neo4jError) { _spi.reportError(neo4jError); if (_state == _failedState) { ConnectionStateConflict.markIgnored(); } else { ConnectionStateConflict.markFailed(neo4jError); } }
//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 public void shouldNotBeAbleToUnpackRelationship() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldNotBeAbleToUnpackRelationship() { try { // When Unpacked(Packed(ALICE_KNOWS_BOB)); fail("exception expected."); } catch (BoltIOException ex) { assertEquals(Neo4jError.from(Org.Neo4j.Kernel.Api.Exceptions.Status_Statement.TypeError, "Relationship values cannot be unpacked with this version of bolt."), Neo4jError.from(ex)); } }
//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); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldCallExternalErrorOnInitWithNullKeys() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldCallExternalErrorOnInitWithNullKeys() { BoltStateMachine stateMachine = mock(typeof(BoltStateMachine)); SynchronousBoltConnection connection = new SynchronousBoltConnection(stateMachine); _channel = new EmbeddedChannel(NewDecoder(connection)); string userAgent = "Test/User Agent 1.0"; IDictionary <string, object> authToken = MapUtil.map("scheme", "basic", null, "user", "credentials", "password"); _channel.writeInbound(Unpooled.wrappedBuffer(serialize(PackerUnderTest, new InitMessage(userAgent, authToken)))); _channel.finishAndReleaseAll(); verify(stateMachine).handleExternalFailure(eq(Neo4jError.from(Org.Neo4j.Kernel.Api.Exceptions.Status_Request.Invalid, "Value `null` is not supported as key in maps, must be a non-nullable string.")), any()); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void testUnpackableStructParametersWithKnownType(org.neo4j.bolt.messaging.Neo4jPack packerForSerialization, org.neo4j.values.AnyValue parameterValue, String expectedMessage) throws Exception private void TestUnpackableStructParametersWithKnownType(Neo4jPack packerForSerialization, AnyValue parameterValue, string expectedMessage) { string statement = "RETURN $x"; MapValue parameters = VirtualValues.map(new string[] { "x" }, new AnyValue[] { parameterValue }); BoltStateMachine stateMachine = mock(typeof(BoltStateMachine)); SynchronousBoltConnection connection = new SynchronousBoltConnection(stateMachine); _channel = new EmbeddedChannel(NewDecoder(connection)); _channel.writeInbound(Unpooled.wrappedBuffer(serialize(packerForSerialization, new RunMessage(statement, parameters)))); _channel.finishAndReleaseAll(); verify(stateMachine).handleExternalFailure(eq(Neo4jError.from(Org.Neo4j.Kernel.Api.Exceptions.Status_Statement.TypeError, expectedMessage)), any()); }
private void Execute(StatementDeserializer statements, ExecutionResultSerializer output, IList <Neo4jError> errors, HttpServletRequest request) { ExecuteStatements(statements, output, errors, request); if (Neo4jError.shouldRollBackOn(errors)) { Rollback(errors); } else { _context.suspendSinceTransactionsAreStillThreadBound(); long lastActiveTimestamp = _registry.release(_id, this); output.TransactionStatus(lastActiveTimestamp); } }
//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 shouldLogShortWarningOnClientDisconnectMidwayThroughQuery() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldLogShortWarningOnClientDisconnectMidwayThroughQuery() { // Connections dying is not exceptional per-se, so we don't need to fill the log with // eye-catching stack traces; but it could be indicative of some issue, so log a brief // warning in the debug log at least. // Given PackOutputClosedException outputClosed = new PackOutputClosedException("Output closed", "<client>"); Neo4jError txTerminated = Neo4jError.from(new TransactionTerminatedException(Org.Neo4j.Kernel.Api.Exceptions.Status_Transaction.Terminated)); // When AssertableLogProvider logProvider = EmulateFailureWritingError(txTerminated, outputClosed); // Then logProvider.AssertExactly(inLog("Test").warn(equalTo("Client %s disconnected while query was running. Session has been cleaned up. " + "This can be caused by temporary network problems, but if you see this often, ensure your " + "applications are properly waiting for operations to complete before exiting."), equalTo("<client>"))); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldNotBeAbleToUnpackPaths() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldNotBeAbleToUnpackPaths() { foreach (PathValue path in ALL_PATHS) { try { // When Unpacked(Packed(path)); fail("exception expected."); } catch (BoltIOException ex) { assertEquals(Neo4jError.from(Org.Neo4j.Kernel.Api.Exceptions.Status_Statement.TypeError, "Path values cannot be unpacked with this version of bolt."), Neo4jError.from(ex)); } } }
//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 WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void read(Neo4jPack_Unpacker unpacker) throws java.io.IOException public virtual void Read(Neo4jPack_Unpacker unpacker) { try { DoRead(unpacker); } catch (BoltIOException e) { if (e.CausesFailureMessage()) { Neo4jError error = Neo4jError.from(e); _connection.enqueue(stateMachine => stateMachine.handleExternalFailure(error, _externalErrorResponseHandler)); } else { throw e; } } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void onlyDatabaseErrorsAreLogged() public virtual void OnlyDatabaseErrorsAreLogged() { AssertableLogProvider userLog = new AssertableLogProvider(); AssertableLogProvider internalLog = new AssertableLogProvider(); ErrorReporter reporter = NewErrorReporter(userLog, internalLog); foreach (Org.Neo4j.Kernel.Api.Exceptions.Status_Classification classification in Enum.GetValues(typeof(Org.Neo4j.Kernel.Api.Exceptions.Status_Classification))) { if (classification != Org.Neo4j.Kernel.Api.Exceptions.Status_Classification.DatabaseError) { Org.Neo4j.Kernel.Api.Exceptions.Status_Code code = NewStatusCode(classification); Neo4jError error = Neo4jError.from(() => code, "Database error"); reporter.Report(error); userLog.AssertNoLoggingOccurred(); internalLog.AssertNoLoggingOccurred(); } } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void databaseErrorShouldLogFullMessageInDebugLogAndHelpfulPointerInUserLog() public virtual void DatabaseErrorShouldLogFullMessageInDebugLogAndHelpfulPointerInUserLog() { // given AssertableLogProvider userLog = new AssertableLogProvider(); AssertableLogProvider internalLog = new AssertableLogProvider(); ErrorReporter reporter = NewErrorReporter(userLog, internalLog); Neo4jError error = Neo4jError.fatalFrom(new TestDatabaseError()); System.Guid reference = error.Reference(); // when reporter.Report(error); // then userLog.RawMessageMatcher().assertContains("Client triggered an unexpected error"); userLog.RawMessageMatcher().assertContains(reference.ToString()); userLog.RawMessageMatcher().assertContains("Database error"); internalLog.RawMessageMatcher().assertContains(reference.ToString()); internalLog.RawMessageMatcher().assertContains("Database error"); }
private void PublishError(BoltResponseMessageWriter messageWriter, Neo4jError error) { try { if (error.Fatal) { messageWriter.Write(new FatalFailureMessage(error.Status(), error.Message())); } else { messageWriter.Write(new FailureMessage(error.Status(), error.Message())); } } catch (PackOutputClosedException e) { // Can't write error to the client, because the connection is closed. // Very likely our error is related to the connection being closed. // If the error is that the transaction was terminated, then the error is a side-effect of // us cleaning up stuff that was running when the client disconnected. Log a warning without // stack trace to highlight clients are disconnecting while stuff is running: if (_clientMidOpDisconnectErrors.Contains(error.Status())) { Log.warn("Client %s disconnected while query was running. Session has been cleaned up. " + "This can be caused by temporary network problems, but if you see this often, " + "ensure your applications are properly waiting for operations to complete before exiting.", e.ClientAddress()); return; } // If the error isn't that the tx was terminated, log it to the console for debugging. It's likely // there are other "ok" errors that we can whitelist into the conditional above over time. Log.warn("Unable to send error back to the client. " + e.Message, error.Cause()); } catch (Exception t) { // some unexpected error happened while writing exception back to the client // log it together with the original error being suppressed t.addSuppressed(error.Cause()); Log.error("Unable to send error back to the client", t); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldNotBeAbleToUnpackUnboundRelationship() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldNotBeAbleToUnpackUnboundRelationship() { // Given PackedOutputArray @out = new PackedOutputArray(); Neo4jPackV1.Packer packer = _neo4jPack.newPacker(@out); packer.packStructHeader(3, UNBOUND_RELATIONSHIP); packer.pack(ValueUtils.of(1L)); packer.pack(ValueUtils.of("RELATES_TO")); packer.pack(ValueUtils.asMapValue(MapUtil.map("a", 1L, "b", "x"))); try { // When Unpacked(@out.Bytes()); fail("exception expected."); } catch (BoltIOException ex) { assertEquals(Neo4jError.from(Org.Neo4j.Kernel.Api.Exceptions.Status_Statement.TypeError, "Relationship values cannot be unpacked with this version of bolt."), Neo4jError.from(ex)); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldThrowOnUnpackingMapWithUnsupportedKeyType() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldThrowOnUnpackingMapWithUnsupportedKeyType() { // Given PackedOutputArray output = new PackedOutputArray(); Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = _neo4jPack.newPacker(output); packer.PackMapHeader(2); packer.Pack(ValueUtils.of(1L)); packer.pack(intValue(1)); // When try { PackedInputArray input = new PackedInputArray(output.Bytes()); Org.Neo4j.Bolt.messaging.Neo4jPack_Unpacker unpacker = _neo4jPack.newUnpacker(input); unpacker.Unpack(); fail("exception expected"); } catch (BoltIOException ex) { assertEquals(Neo4jError.from(Org.Neo4j.Kernel.Api.Exceptions.Status_Request.InvalidFormat, "Bad key type: INTEGER"), Neo4jError.from(ex)); } }
public override void ReportError(Neo4jError err) { _errorReporter.report(err); }
public override void MarkFailed(Neo4jError error) { this._error = error; }
private void ClearState() { _error = null; _ignored = false; _metadata.clear(); }