Merge branch 1.1 into 1.2

Author: lutovich

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

@@ -135,6 +135,12 @@ else if ( state == State.MARKED_FAILED || state == State.ACTIVE )
                 {
                     rollbackTx();
                 }
+                else if ( state == State.FAILED )
+                {
+                    // unrecoverable error happened, transaction should've been rolled back on the server
+                    // update state so that this transaction does not remain open
+                    state = State.ROLLED_BACK;
+                }
             }
         }
         finally
@@ -206,7 +212,7 @@ public synchronized StatementResult run( Statement statement )
     @Override
     public boolean isOpen()
     {
-        return state == State.ACTIVE;
+        return state != State.SUCCEEDED && state != State.ROLLED_BACK;
     }
 
     private void ensureNotFailed()

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

@@ -26,8 +26,11 @@
 
 import org.neo4j.driver.internal.spi.Collector;
 import org.neo4j.driver.internal.spi.Connection;
+import org.neo4j.driver.v1.Transaction;
 import org.neo4j.driver.v1.Value;
 
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
@@ -144,4 +147,82 @@ public void shouldSyncWhenBookmarkGiven()
         inOrder.verify( connection ).pullAll( Collector.NO_OP );
         inOrder.verify( connection ).sync();
     }
+
+    @Test
+    public void shouldBeOpenAfterConstruction()
+    {
+        Transaction tx = new ExplicitTransaction( openConnectionMock(), mock( Runnable.class ) );
+
+        assertTrue( tx.isOpen() );
+    }
+
+    @Test
+    public void shouldBeOpenWhenMarkedForSuccess()
+    {
+        Transaction tx = new ExplicitTransaction( openConnectionMock(), mock( Runnable.class ) );
+
+        tx.success();
+
+        assertTrue( tx.isOpen() );
+    }
+
+    @Test
+    public void shouldBeOpenWhenMarkedForFailure()
+    {
+        Transaction tx = new ExplicitTransaction( openConnectionMock(), mock( Runnable.class ) );
+
+        tx.failure();
+
+        assertTrue( tx.isOpen() );
+    }
+
+    @Test
+    public void shouldBeOpenWhenMarkedToClose()
+    {
+        ExplicitTransaction tx = new ExplicitTransaction( openConnectionMock(), mock( Runnable.class ) );
+
+        tx.markToClose();
+
+        assertTrue( tx.isOpen() );
+    }
+
+    @Test
+    public void shouldBeClosedAfterCommit()
+    {
+        Transaction tx = new ExplicitTransaction( openConnectionMock(), mock( Runnable.class ) );
+
+        tx.success();
+        tx.close();
+
+        assertFalse( tx.isOpen() );
+    }
+
+    @Test
+    public void shouldBeClosedAfterRollback()
+    {
+        Transaction tx = new ExplicitTransaction( openConnectionMock(), mock( Runnable.class ) );
+
+        tx.failure();
+        tx.close();
+
+        assertFalse( tx.isOpen() );
+    }
+
+    @Test
+    public void shouldBeClosedWhenMarkedToCloseAndClosed()
+    {
+        ExplicitTransaction tx = new ExplicitTransaction( openConnectionMock(), mock( Runnable.class ) );
+
+        tx.markToClose();
+        tx.close();
+
+        assertFalse( tx.isOpen() );
+    }
+
+    private static Connection openConnectionMock()
+    {
+        Connection connection = mock( Connection.class );
+        when( connection.isOpen() ).thenReturn( true );
+        return connection;
+    }
 }

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

@@ -734,6 +734,37 @@ public void writeTxRetriedUntilFailureWhenTxCloseThrows()
         testTxIsRetriedUntilFailureWhenTxCloseThrows( WRITE );
     }
 
+    @Test
+    public void transactionShouldBeOpenAfterSessionReset()
+    {
+        ConnectionProvider connectionProvider = mock( ConnectionProvider.class );
+        when( connectionProvider.acquireConnection( READ ) ).thenReturn( openConnectionMock() );
+        NetworkSession session = newSession( connectionProvider, READ );
+        Transaction tx = session.beginTransaction();
+
+        assertTrue( tx.isOpen() );
+
+        session.reset();
+        assertTrue( tx.isOpen() );
+    }
+
+    @Test
+    public void transactionShouldBeClosedAfterSessionResetAndClose()
+    {
+        ConnectionProvider connectionProvider = mock( ConnectionProvider.class );
+        when( connectionProvider.acquireConnection( READ ) ).thenReturn( openConnectionMock() );
+        NetworkSession session = newSession( connectionProvider, READ );
+        Transaction tx = session.beginTransaction();
+
+        assertTrue( tx.isOpen() );
+
+        session.reset();
+        assertTrue( tx.isOpen() );
+
+        tx.close();
+        assertFalse( tx.isOpen() );
+    }
+
     private static void testConnectionAcquisition( AccessMode sessionMode, AccessMode transactionMode )
     {
         ConnectionProvider connectionProvider = mock( ConnectionProvider.class );