Propagate failures when summary is requested

Calls `StatementResult#summary()` and `StatementResultCursor#summaryAsync()`
should propagate unconsumed query errors. They are in this sense same as
`#consume()` and `#consumeAsync()` respectively. Previously summary calls
simply ignored existing unconsumed failure. This commit makes them propagate
it instead. Note that it's later still possible to access summary after
failure is consumed.

Author: lutovich

driver/src/main/java/org/neo4j/driver/internal/handlers/PullAllResponseHandler.java

@@ -142,9 +142,7 @@ public synchronized CompletionStage<Record> peekAsync()
         {
             if ( failure != null )
             {
-                Throwable error = failure;
-                failure = null; // propagate failure only once
-                return failedFuture( error );
+                return failedFuture( extractFailure() );
             }
 
             if ( finished )
@@ -166,17 +164,16 @@ public synchronized CompletionStage<Record> peekAsync()
 
     public synchronized CompletionStage<Record> nextAsync()
     {
-        return peekAsync().thenApply( record ->
-        {
-            dequeueRecord();
-            return record;
-        } );
+        return peekAsync().thenApply( ignore -> dequeueRecord() );
     }
 
-    // todo: propagate failure from here as well
     public synchronized CompletionStage<ResultSummary> summaryAsync()
     {
-        if ( summary != null )
+        if ( failure != null )
+        {
+            return failedFuture( extractFailure() );
+        }
+        else if ( summary != null )
         {
             return completedFuture( summary );
         }
@@ -194,9 +191,7 @@ public synchronized CompletionStage<Throwable> failureAsync()
     {
         if ( failure != null )
         {
-            Throwable error = failure;
-            failure = null; // propagate failure only once
-            return completedFuture( error );
+            return completedFuture( extractFailure() );
         }
         else if ( finished )
         {
@@ -237,6 +232,18 @@ private Record dequeueRecord()
         return record;
     }
 
+    private Throwable extractFailure()
+    {
+        if ( failure == null )
+        {
+            throw new IllegalStateException( "Can't consume failure because it does not exist" );
+        }
+
+        Throwable error = failure;
+        failure = null; // propagate failure only once
+        return error;
+    }
+
     private void completeRecordFuture( Record record )
     {
         if ( recordFuture != null )

driver/src/test/java/org/neo4j/driver/v1/integration/SessionAsyncIT.java

@@ -836,6 +836,24 @@ public void shouldBePossibleToConsumeResultAfterSessionIsClosed()
         assertEquals( 20000, ints.size() );
     }
 
+    @Test
+    public void shouldPropagateFailureFromSummary()
+    {
+        StatementResultCursor cursor = getBlocking( session.runAsync( "RETURN Something" ) );
+
+        try
+        {
+            getBlocking( cursor.summaryAsync() );
+            fail( "Exception expected" );
+        }
+        catch ( ClientException e )
+        {
+            assertThat( e.code(), containsString( "SyntaxError" ) );
+        }
+
+        assertNotNull( getBlocking( cursor.summaryAsync() ) );
+    }
+
     private Future<List<CompletionStage<Record>>> runNestedQueries( StatementResultCursor inputCursor )
     {
         CompletableFuture<List<CompletionStage<Record>>> resultFuture = new CompletableFuture<>();

driver/src/test/java/org/neo4j/driver/v1/integration/SessionIT.java

@@ -1252,6 +1252,27 @@ public void shouldBePossibleToConsumeResultAfterSessionIsClosed()
         assertEquals( 20000, ints.size() );
     }
 
+    @Test
+    public void shouldPropagateFailureFromSummary()
+    {
+        try ( Session session = neo4j.driver().session() )
+        {
+            StatementResult result = session.run( "RETURN Wrong" );
+
+            try
+            {
+                result.summary();
+                fail( "Exception expected" );
+            }
+            catch ( ClientException e )
+            {
+                assertThat( e.code(), containsString( "SyntaxError" ) );
+            }
+
+            assertNotNull( result.summary() );
+        }
+    }
+
     private void assumeServerIs31OrLater()
     {
         ServerVersion serverVersion = ServerVersion.version( neo4j.driver() );

driver/src/test/java/org/neo4j/driver/v1/integration/TransactionAsyncIT.java

@@ -323,8 +323,7 @@ public void shouldAllowRollbackAfterCoupleCorrectAndSingleWrongStatement()
         StatementResultCursor cursor3 = await( tx.runAsync( "RETURN" ) );
         try
         {
-            // todo: use summaryAsync()
-            await( cursor3.consumeAsync() );
+            await( cursor3.summaryAsync() );
             fail( "Exception expected" );
         }
         catch ( Exception e )
@@ -1219,6 +1218,26 @@ public void shouldRollbackWhenPullAllFailureIsConsumed()
         assertNull( getBlocking( tx.rollbackAsync() ) );
     }
 
+    @Test
+    public void shouldPropagateFailureFromSummary()
+    {
+        Transaction tx = getBlocking( session.beginTransactionAsync() );
+
+        StatementResultCursor cursor = getBlocking( tx.runAsync( "RETURN Wrong" ) );
+
+        try
+        {
+            getBlocking( cursor.summaryAsync() );
+            fail( "Exception expected" );
+        }
+        catch ( ClientException e )
+        {
+            assertThat( e.code(), containsString( "SyntaxError" ) );
+        }
+
+        assertNotNull( getBlocking( cursor.summaryAsync() ) );
+    }
+
     private int countNodes( Object id )
     {
         StatementResult result = session.run( "MATCH (n:Node {id: $id}) RETURN count(n)", parameters( "id", id ) );

driver/src/test/java/org/neo4j/driver/v1/integration/TransactionIT.java

@@ -18,7 +18,6 @@
  */
 package org.neo4j.driver.v1.integration;
 
-import org.junit.Assert;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
@@ -35,9 +34,11 @@
 import org.neo4j.driver.v1.exceptions.ClientException;
 import org.neo4j.driver.v1.util.TestNeo4jSession;
 
+import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
@@ -357,9 +358,29 @@ public void shouldRollBackTxIfErrorWithConsume() throws Throwable
                 StatementResult cursor = tx.run( "RETURN 1" );
                 int val = cursor.single().get( "1" ).asInt();
 
-                Assert.assertThat( val, equalTo( 1 ) );
+                assertThat( val, equalTo( 1 ) );
             }
         }
+    }
+
+    @Test
+    public void shouldPropagateFailureFromSummary()
+    {
+        try ( Transaction tx = session.beginTransaction() )
+        {
+            StatementResult result = tx.run( "RETURN Wrong" );
 
+            try
+            {
+                result.summary();
+                fail( "Exception expected" );
+            }
+            catch ( ClientException e )
+            {
+                assertThat( e.code(), containsString( "SyntaxError" ) );
+            }
+
+            assertNotNull( result.summary() );
+        }
     }
 }