Correctly prohibit multiple transactions in session

Session can only have one active (not closed) transaction at a time.
Exception is thrown when starting a transaction on a session that
already has an open one.

Situation when transaction is started multiple times on a session with
an open transaction was not handled correctly. First failure overrode
the reference to the last transaction kept in the session. Later
attempts resulted in a different error saying that there already
exists an open connection.

This commit fixes the problem by making session keep current transaction
reference even if new transaction failed to begin. So callers will
receive consistent errors.

Author: lutovich

driver/src/main/java/org/neo4j/driver/internal/NetworkSession.java

@@ -46,6 +46,7 @@
 import org.neo4j.driver.v1.exceptions.ClientException;
 import org.neo4j.driver.v1.types.TypeSystem;
 
+import static java.util.concurrent.CompletableFuture.completedFuture;
 import static org.neo4j.driver.internal.util.Futures.completedWithNull;
 import static org.neo4j.driver.internal.util.Futures.failedFuture;
 import static org.neo4j.driver.v1.Values.value;
@@ -436,15 +437,32 @@ private CompletionStage<ExplicitTransaction> beginTransactionAsync( AccessMode m
     {
         ensureSessionIsOpen();
 
-        transactionStage = ensureNoOpenTxBeforeStartingTx()
+        // create a chain that acquires connection and starts a transaction
+        CompletionStage<ExplicitTransaction> newTransactionStage = ensureNoOpenTxBeforeStartingTx()
                 .thenCompose( ignore -> acquireConnection( mode ) )
                 .thenCompose( connection ->
                 {
                     ExplicitTransaction tx = new ExplicitTransaction( connection, NetworkSession.this );
                     return tx.beginAsync( bookmark );
                 } );
 
-        return transactionStage;
+        // update the reference to the only known transaction
+        CompletionStage<ExplicitTransaction> currentTransactionStage = transactionStage;
+
+        transactionStage = newTransactionStage
+                .exceptionally( error -> null ) // ignore errors from starting new transaction
+                .thenCompose( tx ->
+                {
+                    if ( tx == null )
+                    {
+                        // failed to begin new transaction, keep reference to the existing one
+                        return currentTransactionStage;
+                    }
+                    // new transaction started, keep reference to it
+                    return completedFuture( tx );
+                } );
+
+        return newTransactionStage;
     }
 
     private CompletionStage<Connection> acquireConnection( AccessMode mode )

driver/src/test/java/org/neo4j/driver/internal/NetworkSessionTest.java

@@ -681,6 +681,53 @@ public void shouldMarkTransactionAsTerminatedAndThenReleaseConnectionOnReset()
         verify( connection ).release();
     }
 
+    @Test
+    public void shouldNotAllowStartingMultipleTransactions()
+    {
+        NetworkSession session = newSession( connectionProvider, READ );
+
+        Transaction tx = session.beginTransaction();
+        assertNotNull( tx );
+
+        for ( int i = 0; i < 5; i++ )
+        {
+            try
+            {
+                session.beginTransaction();
+                fail( "Exception expected" );
+            }
+            catch ( ClientException e )
+            {
+                assertThat( e.getMessage(),
+                        containsString( "You cannot begin a transaction on a session with an open transaction" ) );
+            }
+        }
+    }
+
+    @Test
+    public void shouldAllowStartingTransactionAfterCurrentOneIsClosed()
+    {
+        NetworkSession session = newSession( connectionProvider, READ );
+
+        Transaction tx = session.beginTransaction();
+        assertNotNull( tx );
+
+        try
+        {
+            session.beginTransaction();
+            fail( "Exception expected" );
+        }
+        catch ( ClientException e )
+        {
+            assertThat( e.getMessage(),
+                    containsString( "You cannot begin a transaction on a session with an open transaction" ) );
+        }
+
+        tx.close();
+
+        assertNotNull( session.beginTransaction() );
+    }
+
     private void testConnectionAcquisition( AccessMode sessionMode, AccessMode transactionMode )
     {
         NetworkSession session = newSession( connectionProvider, sessionMode );

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

@@ -1623,6 +1623,34 @@ public void shouldConsumeWithFailure()
         }
     }
 
+    @Test
+    public void shouldNotAllowStartingMultipleTransactions()
+    {
+        try ( Session session = neo4j.driver().session() )
+        {
+            Transaction tx = session.beginTransaction();
+            assertNotNull( tx );
+
+            for ( int i = 0; i < 3; i++ )
+            {
+                try
+                {
+                    session.beginTransaction();
+                    fail( "Exception expected" );
+                }
+                catch ( ClientException e )
+                {
+                    assertThat( e.getMessage(),
+                            containsString( "You cannot begin a transaction on a session with an open transaction" ) );
+                }
+            }
+
+            tx.close();
+
+            assertNotNull( session.beginTransaction() );
+        }
+    }
+
     private void assumeServerIs31OrLater()
     {
         ServerVersion serverVersion = ServerVersion.version( neo4j.driver() );