private MapValue map( Object... keyValues ) { return ValueUtils.asMapValue( MapUtil.map( keyValues ) ); }
private static MapValue map( Object... keyValues ) { return ValueUtils.asMapValue( MapUtil.map( keyValues ) ); }
public TransactionalContext create( HttpServletRequest request, GraphDatabaseQueryService service, Type type, LoginContext loginContext, String query, Map<String, Object> queryParameters ) { TransactionalContextFactory contextFactory = Neo4jTransactionalContextFactory.create( service, locker ); ClientConnectionInfo clientConnection = HttpConnectionInfoFactory.create( request ); InternalTransaction transaction = service.beginTransaction( type, loginContext ); return contextFactory.newContext( clientConnection, transaction, query, ValueUtils.asMapValue( queryParameters ) ); } }
@Test void shouldParseTransactionMetadataCorrectly() throws Throwable { // Given Map<String,Object> txMetadata = map( "creation-time", Duration.ofMillis( 4321L ) ); Map<String,Object> msgMetadata = map( "tx_metadata", txMetadata ); MapValue meta = ValueUtils.asMapValue( msgMetadata ); // When BeginMessage beginMessage = new BeginMessage( meta ); // Then assertThat( beginMessage.transactionMetadata().toString(), equalTo( txMetadata.toString() ) ); }
@Test void shouldParseTransactionTimeoutCorrectly() throws Throwable { // Given Map<String,Object> msgMetadata = map( "tx_timeout", 123456L ); MapValue meta = ValueUtils.asMapValue( msgMetadata ); // When BeginMessage beginMessage = new BeginMessage( meta ); // Then assertThat( beginMessage.transactionTimeout().toMillis(), equalTo( 123456L ) ); } }
@Test void shouldParseTransactionMetadataCorrectly() throws Throwable { // Given Map<String,Object> txMetadata = map( "creation-time", Duration.ofMillis( 4321L ) ); Map<String,Object> msgMetadata = map( "tx_metadata", txMetadata ); MapValue meta = ValueUtils.asMapValue( msgMetadata ); // When RunMessage runMessage = new RunMessage( "RETURN 1", EMPTY_MAP, meta ); // Then assertThat( runMessage.transactionMetadata().toString(), equalTo( txMetadata.toString() ) ); }
@Test void shouldParseTransactionTimeoutCorrectly() throws Throwable { // Given Map<String,Object> msgMetadata = map( "tx_timeout", 123456L ); MapValue meta = ValueUtils.asMapValue( msgMetadata ); // When RunMessage runMessage = new RunMessage( "RETURN 1", EMPTY_MAP, meta ); // Then assertThat( runMessage.transactionTimeout().toMillis(), equalTo( 123456L ) ); } }
private void writeHello( HelloMessage message ) { try { packer.packStructHeader( 0, HelloMessage.SIGNATURE ); packer.pack( ValueUtils.asMapValue( message.meta() ) ); } catch ( IOException e ) { throw new UncheckedIOException( e ); } } }
@Test public void shouldHandleParameterizedStatements() throws Throwable { // Given MapValue parameters = ValueUtils.asMapValue( map( "n", 12L ) ); // When RunMessage msg = serializeAndDeserialize( new RunMessage( "asd", parameters ) ); // Then MapValue params = msg.params(); assertThat( params, equalTo( parameters ) ); }
@Test void shouldBeginTransactionWithMultipleBookmarks() throws Exception { Map<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 ) ); }
@Test public void shouldDispatchRun() throws Exception { BoltStateMachine stateMachine = mock( BoltStateMachine.class ); 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() ); }
@Test void shouldThrowExceptionIfFailedToParseTransactionMetadataCorrectly() throws Throwable { // Given Map<String,Object> msgMetadata = map( "tx_metadata", "invalid value type" ); MapValue meta = ValueUtils.asMapValue( msgMetadata ); // When & Then BoltIOException exception = assertThrows( BoltIOException.class, () -> new BeginMessage( meta ) ); assertThat( exception.getMessage(), startsWith( "Expecting transaction metadata value to be a Map value" ) ); }
@Test void shouldThrowExceptionIfFailedToParseTransactionTimeoutCorrectly() throws Throwable { // Given Map<String,Object> msgMetadata = map( "tx_timeout", "invalid value type" ); MapValue meta = ValueUtils.asMapValue( msgMetadata ); // When & Then BoltIOException exception = assertThrows( BoltIOException.class, () -> new BeginMessage( meta ) ); assertThat( exception.getMessage(), startsWith( "Expecting transaction timeout value to be a Long value" ) ); }
@Test void shouldThrowExceptionIfFailedToParseTransactionMetadataCorrectly() throws Throwable { // Given Map<String,Object> msgMetadata = map( "tx_metadata", "invalid value type" ); MapValue meta = ValueUtils.asMapValue( msgMetadata ); // When & Then BoltIOException exception = assertThrows( BoltIOException.class, () -> new RunMessage( "RETURN 1", EMPTY_MAP, meta ) ); assertThat( exception.getMessage(), startsWith( "Expecting transaction metadata value to be a Map value" ) ); }
@Test void shouldThrowExceptionIfFailedToParseTransactionTimeoutCorrectly() throws Throwable { // Given Map<String,Object> msgMetadata = map( "tx_timeout", "invalid value type" ); MapValue meta = ValueUtils.asMapValue( msgMetadata ); // When & Then BoltIOException exception = assertThrows( BoltIOException.class, () -> new RunMessage( "RETURN 1", EMPTY_MAP, meta ) ); assertThat( exception.getMessage(), startsWith( "Expecting transaction timeout value to be a Long value" ) ); }
@Test void shouldBeginTransactionWithSingleBookmark() throws Exception { Map<String,Object> params = map( "bookmark", "neo4j:bookmark:v1:tx15" ); BoltStateMachineState newState = state.process( new RunMessage( "BEGIN", asMapValue( params ) ), context ); assertEquals( streamingState, newState ); verify( statementProcessor ).beginTransaction( new Bookmark( 15 ) ); }
@Test void shouldThrowForIncorrectTransactionMetadata() { BoltIOException e = assertThrows( BoltIOException.class, () -> parseTransactionMetadata( asMapValue( map( "tx_metadata", "{key1: 'value1', key2: 'value2'}" ) ) ) ); assertTrue( e.causesFailureMessage() ); } }
@Test void shouldThrowForIncorrectTransactionTimeout() { BoltIOException e = assertThrows( BoltIOException.class, () -> parseTransactionTimeout( asMapValue( map( "tx_timeout", "15 minutes" ) ) ) ); assertTrue( e.causesFailureMessage() ); }
private byte[] beginMessage( Map<String,Object> metadata ) throws IOException { PackedOutputArray out = new PackedOutputArray(); Neo4jPack.Packer packer = util.getNeo4jPack().newPacker( out ); packer.packStructHeader( 1, BeginMessage.SIGNATURE ); packer.pack( asMapValue( metadata ) ); return out.bytes(); }
private byte[] runMessage( Map<String,Object> metadata ) throws IOException { PackedOutputArray out = new PackedOutputArray(); Neo4jPack.Packer packer = util.getNeo4jPack().newPacker( out ); packer.packStructHeader( 3, RunMessage.SIGNATURE ); packer.pack( "RETURN 1" ); packer.pack( EMPTY_MAP ); packer.pack( asMapValue( metadata ) ); return out.bytes(); }