//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void testPermutation(byte[] unfragmented, io.netty.buffer.ByteBuf[] fragments) throws Exception private void TestPermutation(sbyte[] unfragmented, ByteBuf[] fragments) { // Given _channel = new EmbeddedChannel(); BoltChannel boltChannel = NewBoltChannel(_channel); BoltStateMachine machine = mock(typeof(BoltStateMachine)); SynchronousBoltConnection boltConnection = new SynchronousBoltConnection(machine); NullLogService logging = NullLogService.Instance; BoltProtocol boltProtocol = new BoltProtocolV1(boltChannel, (ch, s) => boltConnection, (v, ch) => machine, logging); boltProtocol.Install(); // When data arrives split up according to the current permutation foreach (ByteBuf fragment in fragments) { _channel.writeInbound(fragment.readerIndex(0).retain()); } // Then the session should've received the specified messages, and the protocol should be in a nice clean state try { RequestMessage run = new RunMessage("Mjölnir", EMPTY_MAP); verify(machine).process(eq(run), any(typeof(BoltResponseHandler))); } catch (AssertionError e) { throw new AssertionError("Failed to handle fragmented delivery.\n" + "Messages: " + Arrays.ToString(_messages) + "\n" + "Chunk size: " + _chunkSize + "\n" + "Serialized data delivered in fragments: " + DescribeFragments(fragments) + "\n" + "Unfragmented data: " + HexPrinter.hex(unfragmented) + "\n", e); } }
//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()); }
public override BoltConnection NewConnection(BoltChannel channel, BoltStateMachine stateMachine) { requireNonNull(channel); requireNonNull(stateMachine); BoltScheduler scheduler = _schedulerProvider.get(channel); BoltConnectionReadLimiter readLimiter = CreateReadLimiter(_config, _logService); BoltConnectionQueueMonitor connectionQueueMonitor = new BoltConnectionQueueMonitorAggregate(scheduler, readLimiter); ChunkedOutput chunkedOutput = new ChunkedOutput(channel.RawChannel(), _throttleGroup); BoltConnection connection; if (_monitors.hasListeners(typeof(BoltConnectionMetricsMonitor))) { connection = new MetricsReportingBoltConnection(channel, chunkedOutput, stateMachine, _logService, scheduler, connectionQueueMonitor, _metricsMonitor, _clock); } else { connection = new DefaultBoltConnection(channel, chunkedOutput, stateMachine, _logService, scheduler, connectionQueueMonitor); } connection.Start(); return(connection); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldReceiveBookmarkOnCommitAndPullAll() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldReceiveBookmarkOnCommitAndPullAll() { // Given BoltResponseRecorder recorder = new BoltResponseRecorder(); BoltStateMachine machine = Env.newMachine(_boltChannel); machine.Process(new InitMessage(USER_AGENT, emptyMap()), nullResponseHandler()); // When machine.Process(new RunMessage("BEGIN", EMPTY_MAP), recorder); machine.Process(DiscardAllMessage.INSTANCE, recorder); machine.Process(new RunMessage("CREATE (a:Person)", EMPTY_MAP), recorder); machine.Process(DiscardAllMessage.INSTANCE, recorder); machine.Process(new RunMessage("COMMIT", EMPTY_MAP), recorder); machine.Process(PullAllMessage.INSTANCE, recorder); // Then assertThat(recorder.NextResponse(), succeeded()); assertThat(recorder.NextResponse(), succeeded()); assertThat(recorder.NextResponse(), succeeded()); assertThat(recorder.NextResponse(), succeeded()); assertThat(recorder.NextResponse(), succeeded()); assertThat(recorder.NextResponse(), succeededWithMetadata("bookmark", _bookmarkPattern)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Before public void setup() public virtual void Setup() { _boltChannel = new BoltChannel("bolt-1", "bolt", _channel); _stateMachine = mock(typeof(BoltStateMachine)); when(_stateMachine.shouldStickOnThread()).thenReturn(false); when(_stateMachine.hasOpenStatement()).thenReturn(false); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldCloseAutoCommitTransactionAndRespondToNextStatementWhenStreamingFails() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldCloseAutoCommitTransactionAndRespondToNextStatementWhenStreamingFails() { // Given //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.bolt.runtime.BoltStateMachine machine = env.newMachine(BOLT_CHANNEL); BoltStateMachine machine = Env.newMachine(_boltChannel); machine.Process(new InitMessage(USER_AGENT, emptyMap()), nullResponseHandler()); BoltResponseRecorder recorder = new BoltResponseRecorder(); // When machine.Process(new RunMessage("UNWIND [1, 0] AS x RETURN 1 / x", EMPTY_MAP), recorder); machine.Process(PullAllMessage.INSTANCE, recorder); machine.Process(AckFailureMessage.INSTANCE, recorder); machine.Process(new RunMessage("RETURN 2", EMPTY_MAP), recorder); machine.Process(PullAllMessage.INSTANCE, recorder); // Then assertThat(recorder.NextResponse(), succeeded()); assertThat(recorder.NextResponse(), allOf(containsRecord(1L), failedWithStatus(Org.Neo4j.Kernel.Api.Exceptions.Status_Statement.ArithmeticError))); assertThat(recorder.NextResponse(), succeeded()); assertThat(recorder.NextResponse(), succeeded()); assertThat(recorder.NextResponse(), succeededWithRecord(2L)); assertEquals(0, recorder.ResponseCount()); }
public BoltStateMachineV1Context(BoltStateMachine machine, BoltChannel boltChannel, BoltStateMachineSPI spi, MutableConnectionState connectionState, Clock clock) { this._machine = machine; this._boltChannel = boltChannel; this._spi = spi; this._connectionState = connectionState; this._clock = clock; }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldCreateBoltStateMachinesV3() internal virtual void ShouldCreateBoltStateMachinesV3() { BoltStateMachineFactoryImpl factory = NewBoltFactory(); BoltStateMachine boltStateMachine = factory.NewStateMachine(3L, _channel); assertNotNull(boltStateMachine); assertThat(boltStateMachine, instanceOf(typeof(BoltStateMachineV3))); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @ParameterizedTest(name = "V{0}") @ValueSource(longs = {org.neo4j.bolt.v1.BoltProtocolV1.VERSION, org.neo4j.bolt.v2.BoltProtocolV2.VERSION}) void shouldCreateBoltStateMachinesV1(long protocolVersion) internal virtual void ShouldCreateBoltStateMachinesV1(long protocolVersion) { BoltStateMachineFactoryImpl factory = NewBoltFactory(); BoltStateMachine boltStateMachine = factory.NewStateMachine(protocolVersion, _channel); assertNotNull(boltStateMachine); assertThat(boltStateMachine, instanceOf(typeof(BoltStateMachineV1))); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldResetMachine() throws org.neo4j.bolt.runtime.BoltConnectionFatality //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldResetMachine() { BoltStateMachine machine = mock(typeof(BoltStateMachine)); BoltStateMachineV1Context context = NewContext(machine, mock(typeof(BoltStateMachineSPI))); context.ResetMachine(); verify(machine).reset(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldReadYourOwnWrites() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldReadYourOwnWrites() { using (Transaction tx = Env.graph().beginTx()) { Node node = Env.graph().createNode(Label.label("A")); node.SetProperty("prop", "one"); tx.Success(); } BinaryLatch latch = new BinaryLatch(); long dbVersion = Env.lastClosedTxId(); Thread thread = new Thread(() => { try { using (BoltStateMachine machine = Env.newMachine(_boltChannel)) { machine.process(new InitMessage(USER_AGENT, emptyMap()), nullResponseHandler()); latch.Await(); machine.process(new RunMessage("MATCH (n:A) SET n.prop = 'two'", EMPTY_MAP), nullResponseHandler()); machine.process(PullAllMessage.INSTANCE, nullResponseHandler()); } } catch (BoltConnectionFatality connectionFatality) { throw new Exception(connectionFatality); } }); thread.Start(); long dbVersionAfterWrite = dbVersion + 1; using (BoltStateMachine machine = Env.newMachine(_boltChannel)) { BoltResponseRecorder recorder = new BoltResponseRecorder(); machine.process(new InitMessage(USER_AGENT, emptyMap()), nullResponseHandler()); latch.Release(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final String bookmark = "neo4j:bookmark:v1:tx" + dbVersionAfterWrite; string bookmark = "neo4j:bookmark:v1:tx" + dbVersionAfterWrite; machine.process(new RunMessage("BEGIN", ValueUtils.asMapValue(singletonMap("bookmark", bookmark))), nullResponseHandler()); machine.process(PullAllMessage.INSTANCE, recorder); machine.process(new RunMessage("MATCH (n:A) RETURN n.prop", EMPTY_MAP), nullResponseHandler()); machine.process(PullAllMessage.INSTANCE, recorder); machine.process(new RunMessage("COMMIT", EMPTY_MAP), nullResponseHandler()); machine.process(PullAllMessage.INSTANCE, recorder); assertThat(recorder.NextResponse(), succeeded()); assertThat(recorder.NextResponse(), succeededWithRecord("two")); assertThat(recorder.NextResponse(), succeededWithMetadata("bookmark", _bookmarkPattern)); } thread.Join(); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void unpack(byte[] input) throws java.io.IOException private void Unpack(sbyte[] input) { BoltStateMachine stateMachine = mock(typeof(BoltStateMachine)); SynchronousBoltConnection connection = new SynchronousBoltConnection(stateMachine); _channel = new EmbeddedChannel(NewDecoder(connection)); _channel.writeInbound(Unpooled.wrappedBuffer(input)); _channel.finishAndReleaseAll(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldHandleFailure() throws org.neo4j.bolt.runtime.BoltConnectionFatality //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldHandleFailure() { BoltStateMachine machine = mock(typeof(BoltStateMachine)); BoltStateMachineV1Context context = NewContext(machine, mock(typeof(BoltStateMachineSPI))); Exception cause = new Exception(); context.HandleFailure(cause, true); verify(machine).handleFailure(cause, true); }
public virtual BoltStateMachine NewMachine(long version, BoltChannel boltChannel) { if (_boltFactory == null) { throw new System.InvalidOperationException("Cannot access test environment before test is running."); } BoltStateMachine machine = _boltFactory.newStateMachine(version, boltChannel); _runningMachines.Add(machine); return(machine); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldDispatchPullAll() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldDispatchPullAll() { BoltStateMachine stateMachine = mock(typeof(BoltStateMachine)); SynchronousBoltConnection connection = new SynchronousBoltConnection(stateMachine); _channel = new EmbeddedChannel(NewDecoder(connection)); _channel.writeInbound(Unpooled.wrappedBuffer(serialize(PackerUnderTest, PullAllMessage.INSTANCE))); _channel.finishAndReleaseAll(); verify(stateMachine).process(eq(PullAllMessage.INSTANCE), any()); }
public DefaultBoltConnection(BoltChannel channel, PackOutput output, BoltStateMachine machine, LogService logService, BoltConnectionLifetimeListener listener, BoltConnectionQueueMonitor queueMonitor, int maxBatchSize) { this._id = channel.Id(); this._channel = channel; this._output = output; this._machine = machine; this._listener = listener; this._queueMonitor = queueMonitor; this._log = logService.GetInternalLog(this.GetType()); this._userLog = logService.GetUserLog(this.GetType()); this._maxBatchSize = maxBatchSize; this._batch = new List <Job>(maxBatchSize); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldDispatchInit() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldDispatchInit() { 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", "principal", "user", "credentials", "password"); _channel.writeInbound(Unpooled.wrappedBuffer(serialize(PackerUnderTest, new InitMessage(userAgent, authToken)))); _channel.finishAndReleaseAll(); verify(stateMachine).process(refEq(new InitMessage(userAgent, authToken), "authToken"), any()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldDispatchRun() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldDispatchRun() { BoltStateMachine stateMachine = mock(typeof(BoltStateMachine)); SynchronousBoltConnection connection = new SynchronousBoltConnection(stateMachine); _channel = new EmbeddedChannel(NewDecoder(connection)); string statement = "RETURN 1"; MapValue parameters = ValueUtils.asMapValue(MapUtil.map("param1", 1, "param2", "2", "param3", true, "param4", 5.0)); _channel.writeInbound(Unpooled.wrappedBuffer(serialize(PackerUnderTest, new RunMessage(statement, parameters)))); _channel.finishAndReleaseAll(); verify(stateMachine).process(eq(new RunMessage(statement, parameters)), any()); }
//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()); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private static void testMessageDecoding(org.neo4j.bolt.messaging.RequestMessage message) throws Exception private static void TestMessageDecoding(RequestMessage message) { Neo4jPack neo4jPack = newNeo4jPack(); BoltStateMachine stateMachine = mock(typeof(BoltStateMachine)); BoltRequestMessageReader reader = requestMessageReader(stateMachine); PackedInputArray input = new PackedInputArray(encode(neo4jPack, message)); Org.Neo4j.Bolt.messaging.Neo4jPack_Unpacker unpacker = neo4jPack.NewUnpacker(input); reader.Read(unpacker); verify(stateMachine).process(eq(message), any()); }
//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 public void shouldNotFailWhenOutOfOrderRollbackInAutoCommitMode() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldNotFailWhenOutOfOrderRollbackInAutoCommitMode() { // Given BoltResponseRecorder runRecorder = new BoltResponseRecorder(); BoltResponseRecorder pullAllRecorder = new BoltResponseRecorder(); BoltStateMachine machine = Env.newMachine(_boltChannel); machine.Process(new InitMessage(USER_AGENT, emptyMap()), nullResponseHandler()); // When machine.Process(new RunMessage("ROLLBACK", EMPTY_MAP), runRecorder); machine.Process(PullAllMessage.INSTANCE, pullAllRecorder); // Then assertThat(runRecorder.NextResponse(), succeeded()); assertThat(pullAllRecorder.NextResponse(), succeeded()); }
//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 TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldInterpretEmptyStatementAsReuseLastStatementInAutocommitTransaction() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldInterpretEmptyStatementAsReuseLastStatementInAutocommitTransaction() { // Given //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.bolt.runtime.BoltStateMachine machine = env.newMachine(BOLT_CHANNEL); BoltStateMachine machine = Env.newMachine(_boltChannel); machine.Process(new InitMessage(USER_AGENT, emptyMap()), nullResponseHandler()); BoltResponseRecorder recorder = new BoltResponseRecorder(); // When machine.Process(new RunMessage("RETURN 1", EMPTY_MAP), nullResponseHandler()); machine.Process(PullAllMessage.INSTANCE, recorder); machine.Process(new RunMessage("", EMPTY_MAP), nullResponseHandler()); machine.Process(PullAllMessage.INSTANCE, recorder); // Then assertThat(recorder.NextResponse(), succeededWithRecord(1L)); assertThat(recorder.NextResponse(), succeededWithRecord(1L)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldHandleBeginCommit() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldHandleBeginCommit() { // Given BoltResponseRecorder recorder = new BoltResponseRecorder(); BoltStateMachine machine = Env.newMachine(_boltChannel); machine.Process(new InitMessage(USER_AGENT, emptyMap()), nullResponseHandler()); // When machine.Process(new RunMessage("BEGIN", EMPTY_MAP), recorder); machine.Process(DiscardAllMessage.INSTANCE, nullResponseHandler()); machine.Process(new RunMessage("CREATE (n:InTx)", EMPTY_MAP), recorder); machine.Process(DiscardAllMessage.INSTANCE, nullResponseHandler()); machine.Process(new RunMessage("COMMIT", EMPTY_MAP), recorder); machine.Process(DiscardAllMessage.INSTANCE, nullResponseHandler()); // Then assertThat(recorder.NextResponse(), succeeded()); assertThat(recorder.NextResponse(), succeeded()); assertThat(recorder.NextResponse(), succeeded()); }
internal MetricsReportingBoltConnection(BoltChannel channel, PackOutput output, BoltStateMachine machine, LogService logService, BoltConnectionLifetimeListener listener, BoltConnectionQueueMonitor queueMonitor, int maxBatchSize, BoltConnectionMetricsMonitor metricsMonitor, Clock clock) : base(channel, output, machine, logService, listener, queueMonitor, maxBatchSize) { this._metricsMonitor = metricsMonitor; this._clock = clock; }
internal MetricsReportingBoltConnection(BoltChannel channel, PackOutput output, BoltStateMachine machine, LogService logService, BoltConnectionLifetimeListener listener, BoltConnectionQueueMonitor queueMonitor, BoltConnectionMetricsMonitor metricsMonitor, Clock clock) : this(channel, output, machine, logService, listener, queueMonitor, DefaultMaxBatchSize, metricsMonitor, clock) { }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private <T extends org.neo4j.bolt.messaging.RequestMessage> T unpack(RecordingByteChannel channel) throws Exception private T Unpack <T>(RecordingByteChannel channel) where T : Org.Neo4j.Bolt.messaging.RequestMessage { IList <RequestMessage> messages = new List <RequestMessage>(); BoltStateMachine stateMachine = mock(typeof(BoltStateMachine)); doAnswer(new AnswerAnonymousInnerClass(this, messages)) BoltRequestMessageReader reader = new BoltRequestMessageReaderV1(new SynchronousBoltConnection(stateMachine), mock(typeof(BoltResponseMessageWriter)), NullLogService.Instance);
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldTerminateQueriesEvenIfUsingPeriodicCommit() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldTerminateQueriesEvenIfUsingPeriodicCommit() { // Spawns a throttled HTTP server, runs a PERIODIC COMMIT that fetches data from this server, // and checks that the query able to be terminated // We start with 3, because that is how many actors we have - // 1. the http server // 2. the running query // 3. the one terminating 2 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.test.DoubleLatch latch = new org.neo4j.test.DoubleLatch(3, true); DoubleLatch latch = new DoubleLatch(3, true); // This is used to block the http server between the first and second batch //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.test.Barrier_Control barrier = new org.neo4j.test.Barrier_Control(); Org.Neo4j.Test.Barrier_Control barrier = new Org.Neo4j.Test.Barrier_Control(); // Serve CSV via local web server, let Jetty find a random port for us Server server = CreateHttpServer(latch, barrier, 20, 30); server.start(); int localPort = GetLocalPort(server); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.bolt.runtime.BoltStateMachine[] machine = {null}; BoltStateMachine[] machine = new BoltStateMachine[] { null }; Thread thread = new Thread(() => { try { using (BoltStateMachine stateMachine = Env.newMachine(_boltChannel)) { machine[0] = stateMachine; stateMachine.process(new InitMessage(USER_AGENT, emptyMap()), nullResponseHandler()); string query = format("USING PERIODIC COMMIT 10 LOAD CSV FROM 'http://localhost:%d' AS line " + "CREATE (n:A {id: line[0], square: line[1]}) " + "WITH count(*) as number " + "CREATE (n:ShouldNotExist)", localPort); try { latch.Start(); stateMachine.process(new RunMessage(query, EMPTY_MAP), nullResponseHandler()); stateMachine.process(PullAllMessage.INSTANCE, nullResponseHandler()); } finally { latch.Finish(); } } } catch (BoltConnectionFatality connectionFatality) { throw new Exception(connectionFatality); } }); thread.Name = "query runner"; thread.Start(); // We block this thread here, waiting for the http server to spin up and the running query to get started latch.StartAndWaitForAllToStart(); Thread.Sleep(1000); // This is the call that RESETs the Bolt connection and will terminate the running query machine[0].Process(ResetMessage.INSTANCE, nullResponseHandler()); barrier.Release(); // We block again here, waiting for the running query to have been terminated, and for the server to have // wrapped up and finished streaming http results latch.FinishAndWaitForAllToFinish(); // And now we check that the last node did not get created using (Transaction ignored = Env.graph().beginTx()) { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: assertFalse("Query was not terminated in time - nodes were created!", Env.graph().findNodes(Label.label("ShouldNotExist")).hasNext()); } }