Made run, beginTx and reset to be synchronized

to enforce no new statement or tx after reset.
So `reset` could be called during or after running a tx/statement.
While after `session.reset` and/or after the current session is closed,
no more interaction with this session is allowed.

Author: Zhen Li

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

@@ -59,7 +59,7 @@ public void run()
 
     private ExplicitTransaction currentTransaction;
     private AtomicBoolean isOpen = new AtomicBoolean( true );
-    private AtomicBoolean markedToClose = new AtomicBoolean( false );
+    private boolean markedToClose;
 
     NetworkSession( Connection connection, Logger logger )
     {
@@ -94,7 +94,7 @@ public StatementResult run( String statementText, Value statementParameters )
     }
 
     @Override
-    public StatementResult run( Statement statement )
+    public synchronized StatementResult run( Statement statement )
     {
         ensureConnectionIsValidBeforeRunningSession();
         InternalStatementResult cursor = new InternalStatementResult( connection, null, statement );
@@ -104,21 +104,23 @@ public StatementResult run( Statement statement )
         return cursor;
     }
 
-    public void reset()
+    public synchronized void reset()
     {
+        ensureSessionIsOpen();
         ensureNoUnrecoverableError();
         ensureConnectionIsOpen();
 
-        if( markedToClose.compareAndSet( false, true ) )
+        if( !markedToClose )
         {
+            markedToClose = true;
             connection.resetAsync();
         }
     }
 
     @Override
     public boolean isOpen()
     {
-        return isOpen.get() && !markedToClose.get();
+        return isOpen.get() && !markedToClose;
     }
 
     @Override
@@ -166,7 +168,7 @@ public Transaction beginTransaction()
     }
 
     @Override
-    public Transaction beginTransaction( String bookmark )
+    public synchronized Transaction beginTransaction( String bookmark )
     {
         ensureConnectionIsValidBeforeOpeningTransaction();
         currentTransaction = new ExplicitTransaction( connection, txCleanup, bookmark );
@@ -206,13 +208,15 @@ public TypeSystem typeSystem()
 
     private void ensureConnectionIsValidBeforeRunningSession()
     {
+        ensureSessionIsOpen();
         ensureNoUnrecoverableError();
         ensureNoOpenTransactionBeforeRunningSession();
         ensureConnectionIsOpen();
     }
 
     private void ensureConnectionIsValidBeforeOpeningTransaction()
     {
+        ensureSessionIsOpen();
         ensureNoUnrecoverableError();
         ensureNoOpenTransactionBeforeOpeningTransaction();
         ensureConnectionIsOpen();

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

@@ -21,17 +21,13 @@
 import org.junit.Rule;
 import org.junit.Test;
 
-import org.neo4j.driver.v1.AuthToken;
-import org.neo4j.driver.v1.AuthTokens;
-import org.neo4j.driver.v1.Driver;
-import org.neo4j.driver.v1.GraphDatabase;
-import org.neo4j.driver.v1.Session;
-import org.neo4j.driver.v1.StatementResult;
+import org.neo4j.driver.v1.*;
 import org.neo4j.driver.v1.exceptions.ClientException;
 import org.neo4j.driver.v1.exceptions.Neo4jException;
 import org.neo4j.driver.v1.util.TestNeo4j;
 
 import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.startsWith;
 import static org.hamcrest.Matchers.greaterThan;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThat;
@@ -201,4 +197,57 @@ public void run()
             }
         } ).start();
     }
+
+    @Test
+    public void shouldNotAllowMoreStatementAfterSessionReset()
+    {
+        // Given
+        try( Driver driver =  GraphDatabase.driver( neo4j.uri() );
+             Session session = driver.session() )
+        {
+
+            session.run( "Return 1" );
+            session.reset();
+
+            // When & Then
+            try
+            {
+                session.run( "Return 2" );
+                fail( "Should disallow more statements" );
+            }
+            catch( Exception e )
+            {
+                assertThat( e.getMessage(), startsWith("No more interaction with this session is allowed " +
+                        "as the current session is already closed or marked as closed.") );
+            }
+        }
+    }
+
+    @Test
+    public void shouldNotAllowMoreTxAfterSessionReset()
+    {
+        // Given
+        try( Driver driver =  GraphDatabase.driver( neo4j.uri() );
+             Session session = driver.session() )
+        {
+            try( Transaction tx = session.beginTransaction() )
+            {
+                tx.run("Return 1");
+                tx.success();
+            }
+            session.reset();
+
+            // When & Then
+            try
+            {
+                session.beginTransaction();
+                fail( "Should disallow more statements" );
+            }
+            catch( Exception e )
+            {
+                assertThat( e.getMessage(), startsWith("No more interaction with this session is allowed " +
+                        "as the current session is already closed or marked as closed.") );
+            }
+        }
+    }
 }