Updated more deprecated methods to new ones

Author: Zhen Li

driver/src/test/java/org/neo4j/driver/integration/SummaryIT.java

@@ -141,8 +141,8 @@ void shouldGetSystemUpdates() throws Throwable
         try ( Session session = neo4j.driver().session( forDatabase( "system" ) ) )
         {
             StatementResult result = session.run( "CREATE USER foo SET PASSWORD 'bar'" );
-            assertThat( result.summary().counters().containsUpdates(), equalTo( false ) );
-            assertThat( result.summary().counters().containsSystemUpdates(), equalTo( true ) );
+            assertThat( result.consume().counters().containsUpdates(), equalTo( false ) );
+            assertThat( result.consume().counters().containsSystemUpdates(), equalTo( true ) );
         }
     }
 

driver/src/test/java/org/neo4j/driver/integration/reactive/RxTransactionIT.java

@@ -123,7 +123,7 @@ void shouldBePossibleToRunSingleStatementAndCommit()
         Flux<Integer> ids = Flux.usingWhen( session.beginTransaction(),
                 tx -> Flux.from( tx.run( "CREATE (n:Node {id: 42}) RETURN n" ).records() )
                         .map( record -> record.get( 0 ).asNode().get( "id" ).asInt() ),
-                RxTransaction::commit, RxTransaction::rollback );
+                RxTransaction::commit, ( tx, error ) -> tx.rollback(), null );
 
         StepVerifier.create( ids ).expectNext( 42 ).verifyComplete();
         assertEquals( 1, countNodes( 42 ) );
@@ -348,7 +348,7 @@ void shouldAllowRollbackAfterFailedCommit()
     {
         Flux<Record> records = Flux.usingWhen( session.beginTransaction(),
                 tx -> Flux.from( tx.run( "WRONG" ).records() ),
-                RxTransaction::commit, RxTransaction::rollback );
+                RxTransaction::commit, ( tx, error ) -> tx.rollback(), null );
 
         StepVerifier.create( records ).verifyErrorSatisfies( error ->
                 assertThat( error.getMessage(), containsString( "Invalid input" ) ) );
@@ -501,7 +501,7 @@ void shouldFailForEachWhenActionFails()
         Flux<Record> records = Flux.usingWhen( session.beginTransaction(),
                 tx -> Flux.from( tx.run( "RETURN 'Hi!'" ).records() ).doOnNext( record -> { throw e; } ),
                 RxTransaction::commit,
-                RxTransaction::rollback );
+                ( tx, error ) -> tx.rollback(), null );
 
         StepVerifier.create( records ).expectErrorSatisfies( error -> assertEquals( e, error ) ).verify();
     }
@@ -546,7 +546,7 @@ void shouldFailWhenListTransformationFunctionFails()
 
         Flux<Object> records = Flux.usingWhen( session.beginTransaction(),
                 tx -> Flux.from( tx.run( "RETURN 'Hi!'" ).records() ).map( record -> { throw e; } ),
-                RxTransaction::commit, RxTransaction::rollback );
+                RxTransaction::commit, ( tx, error ) -> tx.rollback(), null );
 
         StepVerifier.create( records ).expectErrorSatisfies( error -> {
             assertEquals( e, error );
@@ -680,7 +680,7 @@ void shouldUpdateSessionBookmarkAfterCommit()
         await( Flux.usingWhen( session.beginTransaction(),
                 tx -> tx.run( "CREATE (:MyNode)" ).records(),
                 RxTransaction::commit,
-                RxTransaction::rollback ) );
+                ( tx, error ) -> tx.rollback(), null ) );
 
         Bookmark bookmarkAfter = session.lastBookmark();
 
@@ -795,7 +795,6 @@ private int countNodes( Object id )
 
     private void testForEach( String query, int expectedSeenRecords )
     {
-
         Flux<ResultSummary> summary = Flux.usingWhen( session.beginTransaction(), tx -> {
             RxStatementResult result = tx.run( query );
             AtomicInteger recordsSeen = new AtomicInteger();
@@ -808,7 +807,7 @@ private void testForEach( String query, int expectedSeenRecords )
                         assertEquals( emptyMap(), s.statement().parameters().asMap() );
                         assertEquals( expectedSeenRecords, recordsSeen.get() );
                     } );
-            }, RxTransaction::commit, RxTransaction::rollback );
+        }, RxTransaction::commit, ( tx, error ) -> tx.rollback(), null );
 
         StepVerifier.create( summary ).expectNextCount( 1 ).verifyComplete(); // we indeed get a summary.
     }
@@ -820,7 +819,7 @@ private <T> void testList( String query, List<T> expectedList )
         Flux<List<Record>> records = Flux.usingWhen( session.beginTransaction(),
                 tx -> Flux.from( tx.run( query ).records() ).collectList(),
                 RxTransaction::commit,
-                RxTransaction::rollback );
+                ( tx, error ) -> tx.rollback(), null );
 
         StepVerifier.create( records.single() ).consumeNextWith( allRecords -> {
             for ( Record record : allRecords )
@@ -836,9 +835,7 @@ private void testConsume( String query )
     {
         Flux<ResultSummary> summary = Flux.usingWhen( session.beginTransaction(), tx ->
             tx.run( query ).consume(),
-            RxTransaction::commit,
-            RxTransaction::rollback
-        );
+            RxTransaction::commit, ( tx, error ) -> tx.rollback(), null );
 
         StepVerifier.create( summary.single() ).consumeNextWith( Assertions::assertNotNull ).verifyComplete();
     }

driver/src/test/java/org/neo4j/driver/stress/RxFailingQueryInTx.java

@@ -49,7 +49,7 @@ public CompletionStage<Void> execute( C context )
         RxSession session = newSession( AccessMode.READ, context );
         Flux.usingWhen( session.beginTransaction(),
                 tx -> tx.run( "UNWIND [10, 5, 0] AS x RETURN 10 / x" ).records(),
-                RxTransaction::commit, RxTransaction::rollback )
+                RxTransaction::commit, ( tx, error ) -> tx.rollback(), null )
                 .subscribe( record -> {
                     assertThat( record.get( 0 ).asInt(), either( equalTo( 1 ) ).or( equalTo( 2 ) ) );
                     queryFinished.complete( null );

driver/src/test/java/org/neo4j/driver/stress/RxReadQueryInTx.java

@@ -45,7 +45,8 @@ public CompletionStage<Void> execute( C context )
     {
         CompletableFuture<Void> queryFinished = new CompletableFuture<>();
         RxSession session = newSession( AccessMode.READ, context );
-        Flux.usingWhen( session.beginTransaction(), this::processAndGetSummary, RxTransaction::commit, RxTransaction::rollback )
+        Flux.usingWhen( session.beginTransaction(), this::processAndGetSummary,
+                RxTransaction::commit, ( tx, error ) -> tx.rollback(), null )
                 .subscribe( summary -> {
                     context.readCompleted( summary );
                     queryFinished.complete( null );

driver/src/test/java/org/neo4j/driver/stress/RxWriteQueryInTx.java

@@ -46,7 +46,8 @@ public CompletionStage<Void> execute( C context )
     {
         CompletableFuture<Void> queryFinished = new CompletableFuture<>();
         RxSession session = newSession( AccessMode.WRITE, context );
-        Flux.usingWhen( session.beginTransaction(), tx -> tx.run( "CREATE ()" ).consume(), RxTransaction::commit, RxTransaction::rollback ).subscribe(
+        Flux.usingWhen( session.beginTransaction(), tx -> tx.run( "CREATE ()" ).consume(),
+                RxTransaction::commit, ( tx, error ) -> tx.rollback(), null ).subscribe(
                 summary -> {
                     assertEquals( 1, summary.counters().nodesCreated() );
                     context.nodeCreated();